10284341591

Committed 07 Aug 2024 12:31PM UTC coverage: 85.929% (-0.002%) from 85.931%

Build # 10284341591

Build Type

push

github

Committed by

Buristan

Commit Message

datetime: fix values of unspecified fields in dt.parse()

datetime object can be created using `datetime.new()` and
`datetime.parse()`. `datetime.new()` sets values of unspecified
fields to appropriate values of fields in a Unix time
(00:00:00 UTC on 1 January 1971, Thursday), see commit
43e10ed34949 ("build, lua: built-in module datetime"):

```
tarantool> datetime.new()
---
- 1970-01-01T00:00:00Z
...

tarantool> datetime.new():totable()
---
- sec: 0
  min: 0
  yday: 1
  day: 1
  nsec: 0
  isdst: false
  wday: 5
  tzoffset: 0
  month: 1
  year: 1970
  hour: 0
```

The function `datetime.parse` converts an input string with the
date and time information into a datetime object. When fields are
not specified in a input string their values becomes undefined:

```
tarantool> dt.parse('01:01:01', {format ='%H:%M:%S'}):totable()
---
- sec: -59
  min: -58
  yday: 366
  day: 31
  nsec: 0
  isdst: false
  wday: 1
  tzoffset: 0
  month: 12
  year: 0
  hour: -22
...

tarantool>
```

The commit fixes aforementioned behaviour of `datetime.parse()`
by setting values for fields not specified by user to values of
appropriate fields of Unix time.

NO_DOC=bugfix

Fixes #8588

(cherry picked from commit 9ac56a122)

Run Details

62943 of 114082 branches covered (55.17%)

2 of 2 new or added lines in 1 file covered. (100.0%)

43 existing lines in 10 files now uncovered.

93788 of 109146 relevant lines covered (85.93%)

2601603.7 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.55

/src/histogram.c

/*
 * Copyright 2010-2016, Tarantool AUTHORS, please see AUTHORS file.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *
 * 1. Redistributions of source code must retain the above
 *    copyright notice, this list of conditions and the
 *    following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials
 *    provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
 * <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include "trivia/util.h"
#include "memory.h"
#include "histogram.h"

#include <assert.h>

struct histogram *
histogram_new(const int64_t *buckets, size_t n_buckets)
{
        struct histogram *hist;

        assert(n_buckets > 0);
        for (size_t i = 1; i < n_buckets; i++)
                assert(buckets[i - 1] < buckets[i]);

        hist = malloc(sizeof(*hist) + n_buckets * sizeof(*hist->buckets));
        if (hist == NULL)
                return NULL;

        hist->max = buckets[n_buckets - 1];
        hist->total = 0;
        hist->n_buckets = n_buckets;

        for (size_t i = 0; i < n_buckets; i++) {
                hist->buckets[i].count = 0;
                hist->buckets[i].max = buckets[i];
        }
        return hist;
}

void
histogram_delete(struct histogram *hist)
{
        free(hist);
}

void
histogram_reset(struct histogram *hist)
{
        hist->total = 0;
        for (size_t i = 0; i < hist->n_buckets; i++)
                hist->buckets[i].count = 0;
        hist->max = hist->buckets[hist->n_buckets - 1].max;
}

static struct histogram_bucket *
histogram_lookup_bucket(struct histogram *hist, int64_t val)
{
        size_t begin, end, mid;
        struct histogram_bucket *bucket;

        begin = 0;
        end = hist->n_buckets - 1;
        while (1) {
                if (begin == end) {
                        bucket = &hist->buckets[begin];
                        if (val > bucket->max)
                                bucket = &hist->buckets[end];
                        break;
                } else {
                        mid = begin / 2 + end / 2;
                        bucket = &hist->buckets[mid];
                }

                if (val > hist->buckets[mid].max)
                        begin = mid + 1;
                else
                        end = mid;
        };

        if (val <= bucket->max)
                return bucket;
        return NULL;
}

void
histogram_collect(struct histogram *hist, int64_t val)
{
        struct histogram_bucket *bucket;

        bucket = histogram_lookup_bucket(hist, val);
        if (bucket != NULL)
                bucket->count++;
        if (hist->max < val)
                hist->max = val;
        hist->total++;
}

void
histogram_discard(struct histogram *hist, int64_t val)
{
        struct histogram_bucket *bucket;

        bucket = histogram_lookup_bucket(hist, val);
        if (bucket != NULL) {
                assert(bucket->count > 0);
                bucket->count--;
        }
        assert(hist->total > 0);
        hist->total--;
}

int64_t
histogram_percentile(struct histogram *hist, int pct)
{
        size_t count = 0;

        for (size_t i = 0; i < hist->n_buckets; i++) {
                struct histogram_bucket *bucket = &hist->buckets[i];
                count += bucket->count;
                if (count * 100 > hist->total * pct)
                        return bucket->max;
        }
        return hist->max;
}

int64_t
histogram_percentile_lower(struct histogram *hist, int pct)
{
        size_t count = 0;

        for (size_t i = 0; i < hist->n_buckets; i++) {
                count += hist->buckets[i].count;
                if (count * 100 > hist->total * pct)
                        return hist->buckets[i > 0 ? i - 1 : 0].max;
        }
        return hist->max;
}

int
histogram_snprint(char *buf, int size, struct histogram *hist)
{
        int total = 0;
        bool first = true;

        for (size_t i = 0; i < hist->n_buckets; i++) {
                int64_t count = hist->buckets[i].count;
                if (count == 0)
                        continue;

                int64_t min = (i > 0) ? hist->buckets[i - 1].max + 1 : 0;
                int64_t max = hist->buckets[i].max;

                if (!first)
                        SNPRINT(total, snprintf, buf, size, " ");

                SNPRINT(total, snprintf, buf, size, "[%"PRIi64, min);
                if (max != min)
                        SNPRINT(total, snprintf, buf, size, "-%"PRIi64, max);
                SNPRINT(total, snprintf, buf, size, "]:%"PRIi64, count);

                first = false;
        }
        return total;
}

1	/*
2	* Copyright 2010-2016, Tarantool AUTHORS, please see AUTHORS file.
3	*
4	* Redistribution and use in source and binary forms, with or
5	* without modification, are permitted provided that the following
6	* conditions are met:
7	*
8	* 1. Redistributions of source code must retain the above
9	* copyright notice, this list of conditions and the
10	* following disclaimer.
11	*
12	* 2. Redistributions in binary form must reproduce the above
13	* copyright notice, this list of conditions and the following
14	* disclaimer in the documentation and/or other materials
15	* provided with the distribution.
16	*
17	* THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
18	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
19	* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
21	* <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
22	* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
25	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
26	* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
28	* THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29	* SUCH DAMAGE.
30	*/
31
32	#include "trivia/util.h"
33	#include "memory.h"
34	#include "histogram.h"
35
36	#include <assert.h>
37
38	struct histogram *
39	histogram_new(const int64_t *buckets, size_t n_buckets)	28,485✔
40	{
41	struct histogram *hist;
42
43	assert(n_buckets > 0);	28,485!
44	for (size_t i = 1; i < n_buckets; i++)	1,155,770✔
45	assert(buckets[i - 1] < buckets[i]);	1,127,280!
46
47	hist = malloc(sizeof(hist) + n_buckets sizeof(*hist->buckets));	28,485✔
48	if (hist == NULL)	28,485!
49	return NULL;	×
50
51	hist->max = buckets[n_buckets - 1];	28,485✔
52	hist->total = 0;	28,485✔
53	hist->n_buckets = n_buckets;	28,485✔
54
55	for (size_t i = 0; i < n_buckets; i++) {	1,184,250✔
56	hist->buckets[i].count = 0;	1,155,770✔
57	hist->buckets[i].max = buckets[i];	1,155,770✔
58	}
59	return hist;	28,485✔
60	}
61
62	void
63	histogram_delete(struct histogram *hist)	24,675✔
64	{
65	free(hist);	24,675✔
66	}	24,675✔
67
68	void
69	histogram_reset(struct histogram *hist)	96✔
70	{
71	hist->total = 0;	96✔
72	for (size_t i = 0; i < hist->n_buckets; i++)	5,575✔
73	hist->buckets[i].count = 0;	5,479✔
74	hist->max = hist->buckets[hist->n_buckets - 1].max;	96✔
75	}	96✔
76
77	static struct histogram_bucket *
78	histogram_lookup_bucket(struct histogram *hist, int64_t val)	3,520,080✔
79	{
80	size_t begin, end, mid;
81	struct histogram_bucket *bucket;
82
83	begin = 0;	3,520,080✔
84	end = hist->n_buckets - 1;	3,520,080✔
85	while (1) {
86	if (begin == end) {	24,597,900✔
87	bucket = &hist->buckets[begin];	3,520,080✔
88	if (val > bucket->max)	3,520,080✔
89	bucket = &hist->buckets[end];	669✔
90	break;	3,520,080✔
91	} else {
92	mid = begin / 2 + end / 2;	21,077,800✔
93	bucket = &hist->buckets[mid];	21,077,800✔
94	}
95
96	if (val > hist->buckets[mid].max)	21,077,800✔
97	begin = mid + 1;	257,969✔
98	else
99	end = mid;	20,819,900✔
100	};
101
102	if (val <= bucket->max)	3,520,080✔
103	return bucket;	3,519,410✔
104	return NULL;	669✔
105	}
106
107	void
108	histogram_collect(struct histogram *hist, int64_t val)	3,515,440✔
109	{
110	struct histogram_bucket *bucket;
111
112	bucket = histogram_lookup_bucket(hist, val);	3,515,440✔
113	if (bucket != NULL)	3,515,440✔
114	bucket->count++;	3,514,770✔
115	if (hist->max < val)	3,515,440✔
116	hist->max = val;	12✔
117	hist->total++;	3,515,440✔
118	}	3,515,440✔
119
120	void
121	histogram_discard(struct histogram *hist, int64_t val)	4,636✔
122	{
123	struct histogram_bucket *bucket;
124
125	bucket = histogram_lookup_bucket(hist, val);	4,636✔
126	if (bucket != NULL) {	4,636✔
127	assert(bucket->count > 0);	4,635!
128	bucket->count--;	4,635✔
129	}
130	assert(hist->total > 0);	4,636!
131	hist->total--;	4,636✔
132	}	4,636✔
133
134	int64_t
135	histogram_percentile(struct histogram *hist, int pct)	7,049✔
136	{
137	size_t count = 0;	7,049✔
138
139	for (size_t i = 0; i < hist->n_buckets; i++) {	19,456!
140	struct histogram_bucket *bucket = &hist->buckets[i];	19,456✔
141	count += bucket->count;	19,456✔
142	if (count * 100 > hist->total * pct)	19,456✔
143	return bucket->max;	7,049✔
144	}
UNCOV 145	return hist->max;	×
146	}
147
148	int64_t
149	histogram_percentile_lower(struct histogram *hist, int pct)	65✔
150	{
151	size_t count = 0;	65✔
152
153	for (size_t i = 0; i < hist->n_buckets; i++) {	1,060✔
154	count += hist->buckets[i].count;	1,059✔
155	if (count * 100 > hist->total * pct)	1,059✔
156	return hist->buckets[i > 0 ? i - 1 : 0].max;	64✔
157	}
158	return hist->max;	1✔
159	}
160
161	int
162	histogram_snprint(char buf, int size, struct histogram hist)	1,406✔
163	{
164	int total = 0;	1,406✔
165	bool first = true;	1,406✔
166
167	for (size_t i = 0; i < hist->n_buckets; i++) {	23,902✔
168	int64_t count = hist->buckets[i].count;	22,496✔
169	if (count == 0)	22,496✔
170	continue;	21,079✔
171
172	int64_t min = (i > 0) ? hist->buckets[i - 1].max + 1 : 0;	1,417✔
173	int64_t max = hist->buckets[i].max;	1,417✔
174
175	if (!first)	1,417✔
176	SNPRINT(total, snprintf, buf, size, " ");	11!
177
178	SNPRINT(total, snprintf, buf, size, "[%"PRIi64, min);	1,417!
179	if (max != min)	1,417!
180	SNPRINT(total, snprintf, buf, size, "-%"PRIi64, max);	×
181	SNPRINT(total, snprintf, buf, size, "]:%"PRIi64, count);	1,417!
182
183	first = false;	1,417✔
184	}
185	return total;	1,406✔
186	}

tarantool / tarantool / 10284341591

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous