← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to tests/t/year.test

  • Committer: Jay Pipes
  • Date: 2009-01-28 02:39:29 UTC
  • mto: This revision was merged to the branch mainline in revision 815.
  • Revision ID: jpipes@serialcoder-20090128023929-gy7mot4ki11taytg
First function cleanup for temporal handling: YEAR()

* Added source files for calendrical calculations:
 drizzled/calendar.h
 drizzled/calendar.cc
* Added source files for new Temporal classes
 drizzled/temporal.h
 drizzled/temporal.cc
 drizzled/temporal_format.h
 drizzled/temporal_format.cc

Modified drizzled/function/time/year.cc to use the new
Temporal classes instead of the DRIZZLE_TIME struct and 
get_date().

Added new error codes for invalid DATETIME values and ensured
bad datetimes throw errors in calls to YEAR().

Added new test case specifically for the YEAR() function

Modified existing func_time and type_date test cases to expect
errors when calling YEAR() with bad datetimes.

Edited Makefile.am in drizzled/ to ensure libpcre is used during
build and that calendar.cc, temporal.cc and temporal_format.cc are
built.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/t/year.test
 
1
#
 
2
# Tests for the YEAR() function
 
3
#
 
4
# The Drizzle YEAR() function differs from the MySQL YEAR()
 
5
# function in these ways:
 
6
#
 
7
#  * Does not accept invalid parameters.  This results in an error
 
8
#    in Drizzle.
 
9
#
 
10
 
 
11
# YEAR() on a NULL should produce
 
12
# a NULL.
 
13
SELECT YEAR(NULL);
 
14
 
 
15
# 
 
16
# Test improper argument list 
 
17
#
 
18
# 1 arg is required.
 
19
--error 1064 
 
20
# Wrong parameter count...but unfortunately produces 1064 Syntax Error due to limitations of 
 
21
# the SQL parser, which considers YEAR a keyword before being a function symbol
 
22
SELECT YEAR();
 
23
--error 1064
 
24
# Wrong parameter count...but unfortunately produces 1064 Syntax Error due to limitations of 
 
25
# the SQL parser, which considers YEAR a keyword before being a function symbol
 
26
SELECT YEAR(1, 0);
 
27
 
 
28
# 
 
29
# Test invalid dates passed to YEAR
 
30
# produce an error, not a NULL or anything
 
31
# else...
 
32
#
 
33
--error 1686
 
34
SELECT YEAR("xxx");
 
35
 
 
36
# Indy, bad dates!
 
37
--error 1686
 
38
SELECT YEAR("0000-00-00"); # No 0000-00-00 dates!...
 
39
--error 1686
 
40
SELECT YEAR("0000-01-01"); # No zero year parts
 
41
--error 1686
 
42
SELECT YEAR("0001-00-01"); # No zero month parts
 
43
--error 1686
 
44
SELECT YEAR("0001-01-00"); # No zero day parts
 
45
--error 1686
 
46
SELECT YEAR("2000-02-30"); # No Feb 30th!
 
47
--error 1686
 
48
SELECT YEAR("1900-02-29"); # Not a leap YEAR since not divisible evenly by 400...
 
49
--error 1686
 
50
SELECT YEAR('1976-15-15'); # No 15th month!
 
51
 
 
52
# A good date, which should output 2009
 
53
SELECT YEAR("2009-01-12");
 
54
 
 
55
# A good date, which should output 1970 - Test of 2 digit YEAR conversion...
 
56
SELECT YEAR("70-12-31");
 
57
 
 
58
# A good date, which should output 1999 - Test of 2 digit YEAR conversion...
 
59
SELECT YEAR("99-12-31");
 
60
 
 
61
# A good date, which should output 2069 - Test of 2 digit YEAR conversion...
 
62
SELECT YEAR("69-12-31");
 
63
 
 
64
# A good date, which should output 1
 
65
SELECT YEAR("0001-12-31");
 
66
 
 
67
# A good date, which should output 9999
 
68
SELECT YEAR("9999-12-31");
 
69
 
 
70
# A good date in the common USA format, should output 2007
 
71
SELECT YEAR('07/31/2009');
 
72
 
 
73
# 
 
74
# The following tests should produce errors for YEAR().    
 
75
# 
 
76
 
 
77
#
 
78
# Test boundary dates for YEAR 
 
79
#
 
80
 
 
81
# 
 
82
# Tests for alternate DATETIME syntaxes 
 
83
# in string and numeric formats. All should
 
84
# return 2009.
 
85
#
 
86
SELECT YEAR('20090916');
 
87
SELECT YEAR('20090916091528');
 
88
SELECT YEAR("20090916091528.000000");
 
89
SELECT YEAR('09-09-16');
 
90
SELECT YEAR('09.09.16');
 
91
SELECT YEAR('09/09/16');
 
92
SELECT YEAR('09-09-16');
 
93
SELECT YEAR('09-9-2');
 
94
SELECT YEAR(20090916);
 
95
SELECT YEAR(20090916091528);
 
96
--error 1686 # Don't yet support DOUBLE -> DATETIME.
 
97
SELECT YEAR(20090916091528.000000);
 
98
 
 
99
# Now test field values of different types
 
100
 
 
101
USE test;
 
102
--disable_warnings
 
103
DROP TABLE IF EXISTS t1;
 
104
--enable_warnings
 
105
CREATE TABLE t1 (
 
106
  int_fld INT NOT NULL
 
107
, date_fld DATE NOT NULL
 
108
, datetime_fld DATETIME NOT NULL
 
109
, timestamp_fld TIMESTAMP NOT NULL
 
110
, char_fld CHAR(22) NOT NULL
 
111
, varchar_fld VARCHAR(22) NOT NULL
 
112
, text_fld TEXT NOT NULL
 
113
, blob_fld BLOB NOT NULL
 
114
);
 
115
 
 
116
INSERT INTO t1 VALUES (
 
117
20071130
 
118
, "2007-11-30"
 
119
, "2007-11-30 16:30:19"
 
120
, "2007-11-30T16:30:19"
 
121
, "2007-11-30 16:30:19"
 
122
, "2007-11-30 16:30:19"
 
123
, "2007-11-30T16:30:19"
 
124
, "2007-11-30T16:30:19"
 
125
);
 
126
 
 
127
SELECT YEAR(int_fld) FROM t1;
 
128
SELECT YEAR(date_fld) FROM t1;
 
129
SELECT YEAR(datetime_fld) FROM t1;
 
130
SELECT YEAR(timestamp_fld) FROM t1;
 
131
SELECT YEAR(char_fld) FROM t1;
 
132
SELECT YEAR(varchar_fld) FROM t1;
 
133
SELECT YEAR(text_fld) FROM t1;
 
134
SELECT YEAR(blob_fld) FROM t1;
 
135
 
 
136
DROP TABLE t1;