mtime.c

一个内存数据库的源代码这是服务器端还有客户端

date_extract_month(int *ret, date *v)
{
	if (*v == date_nil) {
		*ret = int_nil;
	} else {
		fromdate((int) *v, &dummy, ret, &dummy);
	}
	return GDK_SUCCEED;
}

/* extracts day from date (value between 1 and 31)*/
int
date_extract_day(int *ret, date *v)
{
	if (*v == date_nil) {
		*ret = int_nil;
	} else {
		fromdate((int) *v, ret, &dummy, &dummy);
	}
	return GDK_SUCCEED;
}

/* Returns N where d is the Nth day of the year (january 1 returns 1). */
int
date_extract_dayofyear(int *ret, date *v)
{
	if (*v == date_nil) {
		*ret = int_nil;
	} else {
		int year;

		fromdate((int) *v, &dummy, &dummy, &year);
		*ret = (int) (1 + *v - todate(1, 1, year));
	}
	return GDK_SUCCEED;
}

/* Returns the week number */
int
date_extract_weekofyear(int *ret, date *v)
{
	if (*v == date_nil) {
		*ret = int_nil;
	} else {
		int year, dayofweek;
		date year_jan_1;

		fromdate((int) *v, &dummy, &dummy, &year);
		dayofweek = date_dayofweek(year_jan_1 = todate(1, 1, year));

		if (dayofweek <= 4) {
			/* week of jan 1 belongs to this year */
			*ret = (int) (1 + (*v - year_jan_1 + dayofweek - 1) / 7);
		} else if (*v - year_jan_1 > 7 - dayofweek) {
			/* week of jan 1 belongs to last year; but this is a later week */
			*ret = (int) ((*v - year_jan_1 + dayofweek - 1) / 7);
		} else {
			/* recurse to get last weekno of previous year (it is 52 or 53) */
			date lastyear_dec_31 = todate(31, 12, (year == 1) ? -1 : year - 1);

			return date_extract_weekofyear(ret, &lastyear_dec_31);
		}
	}
	return GDK_SUCCEED;
}

/* Returns the current day  of the week where 1=monday, .., 7=sunday */
int
date_extract_dayofweek(int *ret, date *v)
{
	if (*v == date_nil) {
		*ret = int_nil;
	} else {
		*ret = date_dayofweek(*v);
	}
	return GDK_SUCCEED;
}

/* extracts hour from daytime (value between 0 and 23) */
int
daytime_extract_hours(int *ret, daytime *v)
{
	if (*v == daytime_nil) {
		*ret = int_nil;
	} else {
		fromtime((int) *v, ret, &dummy, &dummy, &dummy);
	}
	return GDK_SUCCEED;
}

/* extracts minutes from daytime (value between 0 and 59) */
int
daytime_extract_minutes(int *ret, daytime *v)
{
	if (*v == daytime_nil) {
		*ret = int_nil;
	} else {
		fromtime((int) *v, &dummy, ret, &dummy, &dummy);
	}
	return GDK_SUCCEED;
}

/* extracts seconds from daytime (value between 0 and 59) */
int
daytime_extract_seconds(int *ret, daytime *v)
{
	if (*v == daytime_nil) {
		*ret = int_nil;
	} else {
		fromtime((int) *v, &dummy, &dummy, ret, &dummy);
	}
	return GDK_SUCCEED;
}

/* extracts milliseconds from daytime (value between 0 and 999) */
int
daytime_extract_milliseconds(int *ret, daytime *v)
{
	if (*v == daytime_nil) {
		*ret = int_nil;
	} else {
		fromtime((int) *v, &dummy, &dummy, &dummy, ret);
	}
	return GDK_SUCCEED;
}

int
daytime_add(daytime *ret, daytime *v, lng *msec)
{
	if (*v == daytime_nil) {
		*ret = int_nil;
	} else {
		*ret = *v + (daytime) (*msec);
	}
	return GDK_SUCCEED;
}

/* extracts daytime from timestamp */
int
timestamp_extract_daytime(daytime *ret, timestamp *t, tzone *z)
{
	if (ts_isnil(*t) || tz_isnil(*z)) {
		*ret = daytime_nil;
	} else {
		timestamp tmp;

		if (timestamp_inside(&tmp, t, z, (lng) 0)) {
			lng add = (lng) 3600000;

			timestamp_add(&tmp, &tmp, &add);
		}
		if (ts_isnil(tmp)) {
			*ret = daytime_nil;
		} else {
			*ret = tmp.msecs;
		}
	}
	return GDK_SUCCEED;
}

int
timestamp_extract_daytime_default(daytime *ret, timestamp *t)
{
	return timestamp_extract_daytime(ret, t, &tzone_local);
}

/* extracts date from timestamp */
int
timestamp_extract_date(date *ret, timestamp *t, tzone *z)
{
	if (ts_isnil(*t) || tz_isnil(*z)) {
		*ret = date_nil;
	} else {
		timestamp tmp;

		if (timestamp_inside(&tmp, t, z, (lng) 0)) {
			lng add = (lng) 3600000;

			timestamp_add(&tmp, &tmp, &add);
		}
		if (ts_isnil(tmp)) {
			*ret = date_nil;
		} else {
			*ret = tmp.days;
		}
	}
	return GDK_SUCCEED;
}

int
timestamp_extract_date_default(date *ret, timestamp *t)
{
	return timestamp_extract_date(ret, t, &tzone_local);
}

int date_adddays(date *ret, date *v, int *delta);

/* returns the date that comes a number of years after 'v' (or before iff *delta < 0). */
int
date_addyears(date *ret, date *v, int *delta)
{
	if (*v == date_nil || *delta == int_nil) {
		*ret = date_nil;
	} else {
		int d, m, y, x, z = *delta;

		fromdate((int) *v, &d, &m, &y);
		if (m >= 3) {
			y++;
		}
		*ret = *v;
		while (z > 0) {
			x = YEARDAYS(y);
			date_adddays(ret, ret, &x);
			z--;
			y++;
		}
		while (z < 0) {
			z++;
			y--;
			x = -YEARDAYS(y);
			date_adddays(ret, ret, &x);
		}
	}
	return GDK_SUCCEED;
}

/* returns the date that comes a number of months after 'v' (or before iff *delta < 0). */
int
date_addmonths(date *ret, date *v, int *delta)
{
	if (*v == date_nil || *delta == int_nil) {
		*ret = date_nil;
	} else {
		int d, m, y, x, z = *delta;

		fromdate((int) *v, &d, &m, &y);
		*ret = *v;
		while (z > 0) {
			z--;
			x = MONTHDAYS(m, y);
			if (++m == 13)
				m = 1;
			date_adddays(ret, ret, &x);
		}
		while (z < 0) {
			z++;
			if (--m == 0)
				m = 12;
			x = -MONTHDAYS(m, y);
			date_adddays(ret, ret, &x);
		}
	}
	return GDK_SUCCEED;
}

/* returns the date that comes a number of day after 'v' (or before iff *delta < 0). */
int
date_adddays(date *ret, date *v, int *delta)
{
	lng min = DATE_MIN, max = DATE_MAX;
	lng cur = (lng) *v, inc = *delta;

	if (cur == int_nil || inc == int_nil || (inc > 0 && (max - cur) < inc) || (inc < 0 && (min - cur) > inc)) {
		*ret = date_nil;
	} else {
		*ret = *v + *delta;
	}
	return GDK_SUCCEED;
}




/* returns the number of days between 'val1' and 'val2'. */
int
date_diff(int *ret, date *v1, date *v2)
{
	if (*v1 == date_nil || *v2 == date_nil) {
		*ret = int_nil;
	} else {
		*ret = (int) (*v1 - *v2);
	}
	return GDK_SUCCEED;
}

/* returns the timestamp that comes 'milliseconds' after 'value'. */
int
timestamp_add(timestamp *ret, timestamp *v, lng *msecs)
{
	if (!ts_isnil(*v) && *msecs != lng_nil) {
		int days = (int) (*msecs / (24 * 60 * 60 * 1000));

		ret->msecs = (int) (v->msecs + (*msecs - ((lng) days) * (24 * 60 * 60 * 1000)));
		ret->days = v->days;
		if (ret->msecs >= (24 * 60 * 60 * 1000)) {
			days++;
			ret->msecs -= (24 * 60 * 60 * 1000);
		} else if (ret->msecs < 0) {
			days--;
			ret->msecs += (24 * 60 * 60 * 1000);
		}
		if (days) {
			date_adddays(&ret->days, &ret->days, &days);
			if (ret->days == int_nil) {
				*ret = *ts_nilptr;
			}
		}
	} else {
		*ret = *ts_nilptr;
	}
	return GDK_SUCCEED;
}


/* returns the number of milliseconds between 'val1' and 'val2'. */
int
timestamp_diff(lng *ret, timestamp *v1, timestamp *v2)
{
	if (ts_isnil(*v1) || ts_isnil(*v2)) {
		*ret = lng_nil;
	} else {
		*ret = ((lng) (v1->days - v2->days)) * ((lng) 24 * 60 * 60 * 1000) + ((lng) (v1->msecs - v2->msecs));
	}
	return GDK_SUCCEED;
}


/* return whether DST holds in the tzone at a certain point of time. */
int
timestamp_inside_dst(bit *ret, timestamp *p, tzone *z)
{
	*ret = FALSE;

	if (tz_isnil(*z)) {
		*ret = bit_nil;
	} else if (z->dst) {
		timestamp tmp;

		if (timestamp_inside(&tmp, p, z, (lng) 0)) {
			*ret = TRUE;
		}
	}
	return GDK_SUCCEED;
}

/* create a DST start/end date rule. */
int
rule_create(rule *ret, int *month, int *day, int *weekday, int *minutes)
{
	ret->asint = int_nil;
	if (*month >= 1 && *month <= 12 && ABS(*weekday) <= 7 && *minutes >= 0 && *minutes < 24 * 60 && ABS(*day) >= 1 && ABS(*day) <= NODAYS[*month] && (*weekday || *day > 0)) {
		ret->s.month = *month;
		ret->s.day = DAY_ZERO + *day;
		ret->s.weekday = WEEKDAY_ZERO + *weekday;
		ret->s.minutes = *minutes;
	}
	return GDK_SUCCEED;
}

/* create a tzone as a simple hour difference from GMT. */
int
tzone_create_dst(tzone *ret, int *minutes, rule *start, rule *end)
{
	*ret = *tz_nilptr;
	if (*minutes != int_nil && ABS(*minutes) < 24 * 60 && start->asint != int_nil && end->asint != int_nil) {
		set_offset(ret, *minutes);
		ret->dst = TRUE;
		ret->dst_start = get_rule(*start);
		ret->dst_end = get_rule(*end);
	}
	return GDK_SUCCEED;
}

/* create a tzone as an hour difference from GMT and a DST. */
int
tzone_create(tzone *ret, int *minutes)
{
	*ret = *tz_nilptr;
	if (*minutes != int_nil && ABS(*minutes) < 24 * 60) {
		set_offset(ret, *minutes);
		ret->dst = FALSE;
	}
	return GDK_SUCCEED;
}

/* extract month from rule. */
int
rule_extract_month(int *ret, rule *r)
{
	*ret = (r->asint == int_nil) ? int_nil : r->s.month;
	return GDK_SUCCEED;
}

/* extract day from rule. */
int
rule_extract_day(int *ret, rule *r)
{
	*ret = (r->asint == int_nil) ? int_nil : r->s.day - DAY_ZERO;
	return GDK_SUCCEED;
}

/* extract weekday from rule. */
int
rule_extract_weekday(int *ret, rule *r)
{
	*ret = (r->asint == int_nil) ? int_nil : r->s.weekday - WEEKDAY_ZERO;
	return GDK_SUCCEED;
}

/* extract minutes from rule. */
int
rule_extract_minutes(int *ret, rule *r)
{
	*ret = (r->asint == int_nil) ? int_nil : r->s.minutes;
	return GDK_SUCCEED;
}

/* extract rule that determines start of DST from tzone. */
int
tzone_extract_start(rule *ret, tzone *t)
{
	if (tz_isnil(*t) || !t->dst) {
		ret->asint = int_nil;
	} else {
		set_rule(*ret, t->dst_start);
	}
	return GDK_SUCCEED;
}

/* extract rule that determines end of DST from tzone. */
int
tzone_extract_end(rule *ret, tzone *t)
{
	if (tz_isnil(*t) || !t->dst) {
		ret->asint = int_nil;
	} else {
		set_rule(*ret, t->dst_end);
	}
	return GDK_SUCCEED;
}

/* extract number of minutes that tzone is offset wrt GMT. */
int
tzone_extract_minutes(int *ret, tzone *t)
{
	*ret = (tz_isnil(*t)) ? int_nil : get_offset(t);
	return GDK_SUCCEED;
}

int
date_sub_sec_interval_wrap(date *ret, date *t, int *sec)
{
	if (*sec > 0) {
		int delta = (int)(-1 * *sec / 86400);

		return date_adddays(ret, t, &delta);
	}

	return GDK_SUCCEED;
}
int
date_sub_sec_interval_lng_wrap(date *ret, date *t, lng *sec)
{
	if (*sec > 0) {
		int delta = -1 * *sec / 86400;

		return date_adddays(ret, t, &delta);
	}

	return GDK_SUCCEED;
}

int
date_add_sec_interval_wrap(date *ret, date *t, int *sec)
{
	if (*sec > 0) {
		int delta = *sec / 86400;

		return date_adddays(ret, t, &delta);
	}

	return GDK_SUCCEED;
}
int
date_add_sec_interval_lng_wrap(date *ret, date *t, lng *sec)
{
	if (*sec > 0) {
		int delta = (int) (*sec / 86400);

		return date_adddays(ret, t, &delta);
	}

	return GDK_SUCCEED;
}

int
date_sub_month_interval_wrap(date *ret, date *t, int *months)
{
	return date_addmonths(ret, t, months);
}

/* compute the date from a rule in a certain year. */
int
compute_rule_foryear(date *ret, rule *val, int *year)
{
	if (*(int *) val == int_nil || *year < YEAR_MIN || *year > YEAR_MAX) {
		*ret = date_nil;
	} else {
		*ret = compute_rule(val, *year);
	}
	return GDK_SUCCEED;
}



#line 2650 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/atoms/mtime.mx"

#line 2641 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/atoms/mtime.mx"
int date_comp_EQ(bit *retval, date *val1, date *val2)
{
	if (*val1 == date_nil || *val2 == date_nil)
		*retval = bit_nil;
	else
		*retval = *val1 == *val2;
	return GDK_SUCCEED;
}


#line 2650 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/atoms/mtime.mx"


#line 2641 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/atoms/mtime.mx"
int date_comp_NE(bit *retval, date *val1, date *val2)
{
	if (*val1 == date_nil || *val2 == date_nil)
		*retval = bit_nil;
	else
		*retval = *val1 != *val2;
	return GDK_SUCCEED;
}


#line 2651 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/atoms/mtime.mx"


#line 2641 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB5/src/modules/atoms/mtime.mx"
int date_comp_LT(bit *retval, date *val1, date *val2)
{
	if (*val1 == date_nil || *val2 == date_nil)
		*retval = bit_nil;
	else
		*retval = *val1 < *val2;
	return GDK_SUCCEED;