diff --git a/asterix-app/data/nontagged/allData.json b/asterix-app/data/nontagged/allData.json
index e70257a..5f7bf3b 100644
--- a/asterix-app/data/nontagged/allData.json
+++ b/asterix-app/data/nontagged/allData.json
@@ -1,2 +1,2 @@
-{ "id": 10, "name": string("Nancy"), "age": 32.5f, "salary": 12.000 ,"married": boolean("true"), "interests": {{"reading", "writing"}}, "children": ["Brad", "Scott"],  "address": {  "number": 8389,  "street": "Hill St.",  "city": "Mountain View" }, "dob": date("-2011-01-27"), "time": time("12:20:30Z"), "datetime": datetime("-1951-12-27T12:20:30"),  "duration": duration("D10Y11M12DT10H50M30S"),  "location2d": point("41.00,44.00"),  "location3d": point3d("44.00,13.00,41.00"), "line" : line("10.1,11.1 10.2,11.2"), "polygon" : polygon("1.2,1.3 2.1,2.5 3.5,3.6 4.6,4.8"), "circle" : circle("10.1,11.1 10.2") }
+{ "id": 10, "name": string("Nancy"), "age": 32.5f, "salary": 12.000 ,"married": boolean("true"), "interests": {{"reading", "writing"}}, "children": ["Brad", "Scott"],  "address": {  "number": 8389,  "street": "Hill St.",  "city": "Mountain View" }, "dob": date("-2011-01-27"), "time": time("12:20:30Z"), "datetime": datetime("-1951-12-27T12:20:30"),  "duration": duration("P10Y11M12DT10H50M30S"),  "location2d": point("41.00,44.00"),  "location3d": point3d("44.00,13.00,41.00"), "line" : line("10.1,11.1 10.2,11.2"), "polygon" : polygon("1.2,1.3 2.1,2.5 3.5,3.6 4.6,4.8"), "circle" : circle("10.1,11.1 10.2") }
 
diff --git a/asterix-app/data/nontagged/tempData.json b/asterix-app/data/nontagged/tempData.json
index cf04712..a439ab0 100644
--- a/asterix-app/data/nontagged/tempData.json
+++ b/asterix-app/data/nontagged/tempData.json
@@ -1,2 +1,2 @@
-{ "id": 10, "date": date("2011-01-27"), "time": time("12:20:30"), "datetime": datetime("1951-12-27T12:20:30"),  "duration": duration("D30Y10M15DT10H30M50S"), "date2": date("2011-01-27-05:00"), "time2": time("12:20:30.999-05:00"), "datetime2": datetime("1951-12-27T12:20:30.250-08:45"),  "duration2": duration("D10M15DT10H50S"), "date3": date("-2011-01-27-05:00"), "time3": time("12:20:30.999Z"), "datetime3": datetime("-1951-12-27T12:20:30.250-08:15"),  "duration3": duration("-DT50S"), "date4": date("-2011-01-27Z"), "time4": time("12:20:30Z"), "datetime4": datetime("-1951-12-27T12:20:30.250Z"), "duration4": duration("-D10M"), "date5": date("2011-01-27"), "time5": time("12:20:30"), "datetime5": datetime("1951-12-27T12:20:30"),  "duration5": duration("D30Y10M15DT10H30M50S") }
+{ "id": 10, "date": date("2011-01-27"), "time": time("12:20:30"), "datetime": datetime("1951-12-27T12:20:30"),  "duration": duration("P30Y10M15DT10H30M50S"), "date2": date("2011-01-27-05:00"), "time2": time("12:20:30.999-05:00"), "datetime2": datetime("1951-12-27T12:20:30.250-08:45"),  "duration2": duration("P10M15DT10H50S"), "date3": date("-2011-01-27-05:00"), "time3": time("12:20:30.999Z"), "datetime3": datetime("-1951-12-27T12:20:30.250-08:15"),  "duration3": duration("-PT50S"), "date4": date("-2011-01-27Z"), "time4": time("12:20:30Z"), "datetime4": datetime("-1951-12-27T12:20:30.250Z"), "duration4": duration("-P10M"), "date5": date("2011-01-27"), "time5": time("12:20:30"), "datetime5": datetime("1951-12-27T12:20:30"),  "duration5": duration("P30Y10M15DT10H30M50S") }
 
diff --git a/asterix-app/data/nontagged/tempData.txt b/asterix-app/data/nontagged/tempData.txt
index db25721..8790101 100644
--- a/asterix-app/data/nontagged/tempData.txt
+++ b/asterix-app/data/nontagged/tempData.txt
@@ -1,4 +1,4 @@
-10|date("2011-01-27")|time("12:20:30")|datetime("1951-12-27T12:20:30")|duration("D30Y10M15DT10H30M50S")
-20|date("2011-01-27-05:00")|time("12:20:30.999-05:00")|datetime("1951-12-27T12:20:30.250-08:45")|duration("D10M15DT10H50S")
-30|date("-2011-01-27-05:00")|time("12:20:30.999Z")|datetime("-1951-12-27T12:20:30.250-08:15")|duration("-DT50S")
-40|date("-2011-01-27Z")|time("12:20:30Z")|datetime("-1951-12-27T12:20:30.250Z")|duration("-D10M")
+10|date("2011-01-27")|time("12:20:30")|datetime("1951-12-27T12:20:30")|duration("P30Y10M15DT10H30M50S")
+20|date("2011-01-27-05:00")|time("12:20:30.999-05:00")|datetime("1951-12-27T12:20:30.250-08:45")|duration("P10M15DT10H50S")
+30|date("-2011-01-27-05:00")|time("12:20:30.999Z")|datetime("-1951-12-27T12:20:30.250-08:15")|duration("-PT50S")
+40|date("-2011-01-27Z")|time("12:20:30Z")|datetime("-1951-12-27T12:20:30.250Z")|duration("-P10M")
diff --git a/asterix-app/src/test/resources/runtimets/queries/comparison/datetime_order.aql b/asterix-app/src/test/resources/runtimets/queries/comparison/datetime_order.aql
index 2e151ab..f2d8208 100644
--- a/asterix-app/src/test/resources/runtimets/queries/comparison/datetime_order.aql
+++ b/asterix-app/src/test/resources/runtimets/queries/comparison/datetime_order.aql
@@ -11,7 +11,13 @@
 let $dt3 := datetime("2005-01-01T00:00:00+04:00")
 let $dt4 := datetime("2011-12-31T13:00:00-11:00")
 let $dt5 := datetime("2012-04-06T00:00:00Z")
+let $dt6 := datetime("-1937-07-07T23:00:00+08:00")
+let $dt7 := datetime("-1600-03-01T00:00:00.384+06:00")
+let $dt8 := datetime("-1600-02-29T23:59:59.999Z")
+let $dt9 := datetime("2000-02-29T23:59:59.999Z")
+let $dt10 := datetime("2000-03-01T01:59:59.999+07:00")
+let $dt11 := datetime("-1600-03-01T00:00:00.384-06:00")
 
-for $dt in [$dt1, $dt2, $dt3, $dt4, $dt5]
+for $dt in [$dt1, $dt2, $dt3, $dt4, $dt5, $dt6, $dt7, $dt8, $dt9, $dt10, $dt11]
 order by $dt
 return $dt
\ No newline at end of file
diff --git a/asterix-app/src/test/resources/runtimets/queries/comparison/datetime_tzeq.aql b/asterix-app/src/test/resources/runtimets/queries/comparison/datetime_tzeq.aql
index e38bdae..1a0bb52 100644
--- a/asterix-app/src/test/resources/runtimets/queries/comparison/datetime_tzeq.aql
+++ b/asterix-app/src/test/resources/runtimets/queries/comparison/datetime_tzeq.aql
@@ -8,6 +8,10 @@
 
 let $dt1 := datetime("2011-12-31T14:00:00-10:00")
 let $dt2 := datetime("2012-01-01T00:00:00Z")
+let $dt3 := datetime("2000-03-01T02:00:00+04:00")
+let $dt4 := datetime("2000-02-29T22:00:00Z")
+let $r1 := $dt1 = $dt2
+let $r2 := $dt3 = $dt4
 
 
-return [$dt1 = $dt2]
\ No newline at end of file
+return { "result1": $r1,"result2": $r2 }
\ No newline at end of file
diff --git a/asterix-app/src/test/resources/runtimets/queries/constructor/date_01.aql b/asterix-app/src/test/resources/runtimets/queries/constructor/date_01.aql
index c889627..9cc3d15 100644
--- a/asterix-app/src/test/resources/runtimets/queries/constructor/date_01.aql
+++ b/asterix-app/src/test/resources/runtimets/queries/constructor/date_01.aql
@@ -11,5 +11,11 @@
 let $c5 := date("-1987-11-19+08:30")
 let $c6 := date("0001-12-27")
 let $c7 := date("-1951-01-27-01:45")
-return {"date1": $c1, "date2": $c2, "date3": $c3, "date4": $c4, "date5": $c5, "date6": $c6, "date7": $c7}
+let $c8 := date("-2043-11-19Z")
+let $c9 := date("-19280329-0630")
+let $c10 := date("-19280329+0630")
+let $c11 := date("-19280329")
+let $c12 := date("-19280229")
+let $c13 := date("-19280301+0630")
+return {"date1": $c1, "date2": $c2, "date3": $c3, "date4": $c4, "date5": $c5, "date6": $c6, "date7": $c7, "date8": $c8, "date9": $c9, "date10": $c10, "date11": $c11, "date12": $c12, "date13": $c13}
 
diff --git a/asterix-app/src/test/resources/runtimets/queries/constructor/datetime_01.aql b/asterix-app/src/test/resources/runtimets/queries/constructor/datetime_01.aql
index 8c29dac..b883b8a 100644
--- a/asterix-app/src/test/resources/runtimets/queries/constructor/datetime_01.aql
+++ b/asterix-app/src/test/resources/runtimets/queries/constructor/datetime_01.aql
@@ -11,5 +11,12 @@
 let $c5 := datetime("-1987-11-19T10:50:56.099-05:30")
 let $c6 := datetime("-0001-11-19T10:50:56.719Z")
 let $c7 := datetime("1951-12-27T12:20:15Z")
-return {"datetime1": $c1, "datetime2": $c2, "datetime3": $c3, "datetime4": $c4, "datetime5": $c5, "datetime6": $c6, "datetime7": $c7}
+let $c8 := datetime("2043-11-19T10:50:56.719938747Z")
+let $c9 := datetime("-19280329174937374-0630")
+let $c10 := datetime("-19280329174937374+0630")
+let $c11 := datetime("-19280329174937374")
+let $c12 := datetime("-19280329174937374847374+0630")
+let $c13 := datetime("-1928032917493737+0630")
+let $c14 := datetime("-1928030105493737+0630")
+return {"datetime1": $c1, "datetime2": $c2, "datetime3": $c3, "datetime4": $c4, "datetime5": $c5, "datetime6": $c6, "datetime7": $c7, "datetime8": $c8, "datetime9": $c9, "datetime10": $c10, "datetime11": $c11, "datetime12": $c12, "datetime13": $c13, "datetime14": $c14}
 
diff --git a/asterix-app/src/test/resources/runtimets/queries/constructor/duration_01.aql b/asterix-app/src/test/resources/runtimets/queries/constructor/duration_01.aql
index 011996c..4d9df8c 100644
--- a/asterix-app/src/test/resources/runtimets/queries/constructor/duration_01.aql
+++ b/asterix-app/src/test/resources/runtimets/queries/constructor/duration_01.aql
@@ -4,13 +4,18 @@
 
 write output to nc1:"rttest/constructor_duration_01.adm";
 
-let $c1 := duration("D30Y10M25DT13H12M50S")
-let $c2 := duration("D25DT13H12M50S")
-let $c3 := duration("DT13H12M50S")
-let $c4 := duration("D30YT12MS")
-let $c5 := duration("DT13H")
-let $c6 := duration("-D30Y10M25DT13H12M50S")
-let $c7 := duration("-D25DT13H12M50S")
-let $c8 := duration("-DT13H50S")
-return {"duration1": $c1, "duration2": $c2, "duration3": $c3, "duration4": $c4, "duration5": $c5, "duration6": $c6, "duration7": $c7, "duration8": $c8}
+let $c1 := duration("P30Y10M25DT13H12M50S")
+let $c2 := duration("P25DT13H12M50S")
+let $c3 := duration("PT13H12M50S")
+let $c4 := duration("P30YT12MS")
+let $c5 := duration("PT13H")
+let $c6 := duration("-P30Y10M25DT13H12M50S")
+let $c7 := duration("-P25DT13H12M50S")
+let $c8 := duration("-PT13H50S")
+let $c9 := duration("P120D")
+let $c10 := duration("-P28M")
+let $c11 := duration("PT29M90.937S")
+let $c12 := duration("P300Y15M60DT300H98M482.43S")
+let $c13 := duration("P300Y15M60DT300H98M482.43493848S")
+return {"duration1": $c1, "duration2": $c2, "duration3": $c3, "duration4": $c4, "duration5": $c5, "duration6": $c6, "duration7": $c7, "duration8": $c8, "duration9": $c9, "duration10": $c10, "duration11": $c11, "duration12": $c12, "duration13": $c13}
 
diff --git a/asterix-app/src/test/resources/runtimets/queries/constructor/time_01.aql b/asterix-app/src/test/resources/runtimets/queries/constructor/time_01.aql
index 3936b21..bb5d313 100644
--- a/asterix-app/src/test/resources/runtimets/queries/constructor/time_01.aql
+++ b/asterix-app/src/test/resources/runtimets/queries/constructor/time_01.aql
@@ -11,5 +11,9 @@
 let $c5 := time("23:59:59.999-13:30")
 let $c6 := time("00:00:00.000+14:45")
 let $c7 := time("12:59:00.019-01:00")
-return {"time1": $c1, "time2": $c2, "time3": $c3, "time4": $c4, "time5": $c5, "time6": $c6, "time7": $c7}
+let $c8 := time("12:59:00.01-01:00")
+let $c9 := time("12:59:00.0193823-01:00")
+let $c10 := time("12590001-0100")
+let $c11 := time("125900019382382398238-0100")
+return {"time1": $c1, "time2": $c2, "time3": $c3, "time4": $c4, "time5": $c5, "time6": $c6, "time7": $c7, "time8": $c8, "time9": $c9, "time10": $c10, "time11": $c11}
 
diff --git a/asterix-app/src/test/resources/runtimets/results/comparison/datetime_order.adm b/asterix-app/src/test/resources/runtimets/results/comparison/datetime_order.adm
index 63d22af..21f8208 100644
--- a/asterix-app/src/test/resources/runtimets/results/comparison/datetime_order.adm
+++ b/asterix-app/src/test/resources/runtimets/results/comparison/datetime_order.adm
@@ -1,3 +1,9 @@
+datetime("-1937-07-07T15:00:00.000Z")
+datetime("-1600-02-29T18:00:00.384Z")
+datetime("-1600-02-29T23:59:59.999Z")
+datetime("-1600-03-01T06:00:00.384Z")
+datetime("2000-02-29T18:59:59.999Z")
+datetime("2000-02-29T23:59:59.999Z")
 datetime("2004-12-31T20:00:00.000Z")
 datetime("2012-01-01T00:00:00.000Z")
 datetime("2012-01-01T00:00:00.000Z")
diff --git a/asterix-app/src/test/resources/runtimets/results/comparison/datetime_tzeq.adm b/asterix-app/src/test/resources/runtimets/results/comparison/datetime_tzeq.adm
index 5dc225e..167bafb 100644
--- a/asterix-app/src/test/resources/runtimets/results/comparison/datetime_tzeq.adm
+++ b/asterix-app/src/test/resources/runtimets/results/comparison/datetime_tzeq.adm
@@ -1 +1 @@
-[ true ]
+{ "result1": true, "result2": true }
diff --git a/asterix-app/src/test/resources/runtimets/results/constructor/date_01.adm b/asterix-app/src/test/resources/runtimets/results/constructor/date_01.adm
index b0cb1e4..12f5755 100644
--- a/asterix-app/src/test/resources/runtimets/results/constructor/date_01.adm
+++ b/asterix-app/src/test/resources/runtimets/results/constructor/date_01.adm
@@ -1 +1 @@
-{ "date1": date("2010-10-30+05:00"), "date2": date("2010-10-30-10:15"), "date3": date("1987-11-19+00:00"), "date4": date("1987-11-19+00:00"), "date5": date("-1987-11-19+08:30"), "date6": date("0001-12-27+00:00"), "date7": date("-1951-01-27-01:45") }
\ No newline at end of file
+{ "date1": date("2010-10-29Z"), "date2": date("2010-10-30Z"), "date3": date("1987-11-19Z"), "date4": date("1987-11-19Z"), "date5": date("-1987-11-18Z"), "date6": date("0001-12-27Z"), "date7": date("-1951-01-27Z"), "date8": date("-2043-11-19Z"), "date9": date("-1928-03-29Z"), "date10": date("-1928-03-28Z"), "date11": date("-1928-03-29Z"), "date12": date("-1928-02-29Z"), "date13": date("-1928-02-29Z") }
\ No newline at end of file
diff --git a/asterix-app/src/test/resources/runtimets/results/constructor/datetime_01.adm b/asterix-app/src/test/resources/runtimets/results/constructor/datetime_01.adm
index 8f2dff0..54e76c4 100644
--- a/asterix-app/src/test/resources/runtimets/results/constructor/datetime_01.adm
+++ b/asterix-app/src/test/resources/runtimets/results/constructor/datetime_01.adm
@@ -1 +1 @@
-{ "datetime1": datetime("2010-10-30T05:05:56.999Z"), "datetime2": datetime("2010-10-30T20:30:56.250Z"), "datetime3": datetime("1987-11-19T09:20:00.200Z"), "datetime4": datetime("1987-11-19T10:50:56.000Z"), "datetime5": datetime("-1987-11-19T16:20:56.099Z"), "datetime6": datetime("-0001-11-19T10:50:56.719Z"), "datetime7": datetime("1951-12-27T12:20:15.000Z") }
+{ "datetime1": datetime("2010-10-30T05:05:56.999Z"), "datetime2": datetime("2010-10-30T20:30:56.250Z"), "datetime3": datetime("1987-11-19T09:20:00.200Z"), "datetime4": datetime("1987-11-19T10:50:56.000Z"), "datetime5": datetime("-1987-11-19T16:20:56.099Z"), "datetime6": datetime("-0001-11-19T10:50:56.719Z"), "datetime7": datetime("1951-12-27T12:20:15.000Z"), "datetime8": datetime("2043-11-19T10:50:56.719Z"), "datetime9": datetime("-1928-03-30T00:19:37.374Z"), "datetime10": datetime("-1928-03-29T11:19:37.374Z"), "datetime11": datetime("-1928-03-29T17:49:37.374Z"), "datetime12": datetime("-1928-03-29T11:19:37.374Z"), "datetime13": datetime("-1928-03-29T11:19:37.370Z"), "datetime14": datetime("-1928-02-29T23:19:37.370Z") }
diff --git a/asterix-app/src/test/resources/runtimets/results/constructor/duration_01.adm b/asterix-app/src/test/resources/runtimets/results/constructor/duration_01.adm
index b80ed1a..d9c8359 100644
--- a/asterix-app/src/test/resources/runtimets/results/constructor/duration_01.adm
+++ b/asterix-app/src/test/resources/runtimets/results/constructor/duration_01.adm
@@ -1 +1 @@
-{ "duration1": duration("D30Y10M25DT13H12M50S"), "duration2": duration("D0Y0M25DT13H12M50S"), "duration3": duration("D0Y0M0DT13H12M50S"), "duration4": duration("D30Y0M0DT0H12M0S"), "duration5": duration("D0Y0M0DT13H0M0S"), "duration6": duration("-D30Y10M25DT13H12M50S"), "duration7": duration("-D0Y0M25DT13H12M50S"), "duration8": duration("-D0Y0M0DT13H0M50S") }
+{ "duration1": duration("P30Y10M25DT13H12M50S"), "duration2": duration("P0Y0M25DT13H12M50S"), "duration3": duration("P0Y0M0DT13H12M50S"), "duration4": duration("P30Y0M0DT0H12M0S"), "duration5": duration("P0Y0M0DT13H0M0S"), "duration6": duration("-P30Y10M25DT13H12M50S"), "duration7": duration("-P0Y0M25DT13H12M50S"), "duration8": duration("-P0Y0M0DT13H0M50S"), "duration9": duration("P0Y0M120DT0H0M0S"), "duration10": duration("-P2Y4M0DT0H0M0S"), "duration11": duration("P0Y0M0DT0H30M30.937S"), "duration12": duration("P301Y3M72DT13H46M2.43S"), "duration13": duration("P301Y3M72DT13H46M2.434S") }
diff --git a/asterix-app/src/test/resources/runtimets/results/constructor/time_01.adm b/asterix-app/src/test/resources/runtimets/results/constructor/time_01.adm
index 009ad39..ef6adc9 100644
--- a/asterix-app/src/test/resources/runtimets/results/constructor/time_01.adm
+++ b/asterix-app/src/test/resources/runtimets/results/constructor/time_01.adm
@@ -1 +1 @@
-{ "time1": time("05:50:56.200Z"), "time2": time("21:05:56.200Z"), "time3": time("10:50:56.000Z"), "time4": time("10:50:56.200Z"), "time5": time("13:29:59.999Z"), "time6": time("09:15:00.000Z"), "time7": time("13:59:00.019Z") }
+{ "time1": time("05:50:56.200Z"), "time2": time("21:05:56.200Z"), "time3": time("10:50:56.000Z"), "time4": time("10:50:56.200Z"), "time5": time("13:29:59.999Z"), "time6": time("09:15:00.000Z"), "time7": time("13:59:00.019Z"), "time8": time("13:59:00.010Z"), "time9": time("13:59:00.019Z"), "time10": time("13:59:00.010Z"), "time11": time("13:59:00.019Z") }
diff --git a/asterix-app/src/test/resources/runtimets/results/scan/alltypes_01.adm b/asterix-app/src/test/resources/runtimets/results/scan/alltypes_01.adm
index e317c7e..06adc49 100644
--- a/asterix-app/src/test/resources/runtimets/results/scan/alltypes_01.adm
+++ b/asterix-app/src/test/resources/runtimets/results/scan/alltypes_01.adm
@@ -1 +1 @@
-{ "id": 10, "name": "Nancy", "age": 32.5f, "salary": 12.0d, "married": true, "interests": {{ "reading", "writing" }}, "children": [ "Brad", "Scott" ], "address": { "number": 8389, "street": "Hill St.", "city": "Mountain View" }, "dob": date("-2011-01-27+00:00"), "time": time("12:20:30.000Z"), "datetime": datetime("-1951-12-27T12:20:30.000Z"), "duration": duration("D10Y11M12DT10H50M30S"), "location2d": point("41.0,44.0"), "location3d": point3d("44.0,13.0,41.0"), "line": line("10.1,11.1 10.2,11.2"), "polygon": polygon("1.2,1.3 2.1,2.5 3.5,3.6 4.6,4.8"), "circle": circle("10.1,11.1 10.2") }
+{ "id": 10, "name": "Nancy", "age": 32.5f, "salary": 12.0d, "married": true, "interests": {{ "reading", "writing" }}, "children": [ "Brad", "Scott" ], "address": { "number": 8389, "street": "Hill St.", "city": "Mountain View" }, "dob": date("-2011-01-27Z"), "time": time("12:20:30.000Z"), "datetime": datetime("-1951-12-27T12:20:30.000Z"), "duration": duration("P10Y11M12DT10H50M30S"), "location2d": point("41.0,44.0"), "location3d": point3d("44.0,13.0,41.0"), "line": line("10.1,11.1 10.2,11.2"), "polygon": polygon("1.2,1.3 2.1,2.5 3.5,3.6 4.6,4.8"), "circle": circle("10.1,11.1 10.2") }
diff --git a/asterix-app/src/test/resources/runtimets/results/scan/temp_types_01.adm b/asterix-app/src/test/resources/runtimets/results/scan/temp_types_01.adm
index 16e2241..7d57c24 100644
--- a/asterix-app/src/test/resources/runtimets/results/scan/temp_types_01.adm
+++ b/asterix-app/src/test/resources/runtimets/results/scan/temp_types_01.adm
@@ -1 +1 @@
-{ "id": 10, "date": date("2011-01-27+00:00"), "time": time("12:20:30.000Z"), "datetime": datetime("1951-12-27T12:20:30.000Z"), "duration": duration("D30Y10M15DT10H30M50S"), "date2": date("2011-01-27-05:00"), "time2": time("17:20:30.999Z"), "datetime2": datetime("1951-12-27T21:05:30.250Z"), "duration2": duration("D0Y10M15DT10H0M50S"), "date3": date("-2011-01-27-05:00"), "time3": time("12:20:30.999Z"), "datetime3": datetime("-1951-12-27T20:35:30.250Z"), "duration3": duration("-D0Y0M0DT0H0M50S"), "date4": date("-2011-01-27+00:00"), "time4": time("12:20:30.000Z"), "datetime4": datetime("-1951-12-27T12:20:30.250Z"), "duration4": duration("-D0Y10M0DT0H0M0S"), "date5": date("2011-01-27+00:00"), "time5": time("12:20:30.000Z"), "datetime5": datetime("1951-12-27T12:20:30.000Z"), "duration5": duration("D30Y10M15DT10H30M50S") }
\ No newline at end of file
+{ "id": 10, "date": date("2011-01-27Z"), "time": time("12:20:30.000Z"), "datetime": datetime("1951-12-27T12:20:30.000Z"), "duration": duration("P30Y10M15DT10H30M50S"), "date2": date("2011-01-27Z"), "time2": time("17:20:30.999Z"), "datetime2": datetime("1951-12-27T21:05:30.250Z"), "duration2": duration("P0Y10M15DT10H0M50S"), "date3": date("-2011-01-27Z"), "time3": time("12:20:30.999Z"), "datetime3": datetime("-1951-12-27T20:35:30.250Z"), "duration3": duration("-P0Y0M0DT0H0M50S"), "date4": date("-2011-01-27Z"), "time4": time("12:20:30.000Z"), "datetime4": datetime("-1951-12-27T12:20:30.250Z"), "duration4": duration("-P0Y10M0DT0H0M0S"), "date5": date("2011-01-27Z"), "time5": time("12:20:30.000Z"), "datetime5": datetime("1951-12-27T12:20:30.000Z"), "duration5": duration("P30Y10M15DT10H30M50S") }
\ No newline at end of file
diff --git a/asterix-app/src/test/resources/runtimets/results/scan/temp_types_02.adm b/asterix-app/src/test/resources/runtimets/results/scan/temp_types_02.adm
index 701d172..5f39ed9 100644
--- a/asterix-app/src/test/resources/runtimets/results/scan/temp_types_02.adm
+++ b/asterix-app/src/test/resources/runtimets/results/scan/temp_types_02.adm
@@ -1,4 +1,4 @@
-{ "id": 10, "date": date("2011-01-27+00:00"), "time": time("12:20:30.000Z"), "datetime": datetime("1951-12-27T12:20:30.000+00:00"), "duration": duration("D30Y10M15DT10H30M50S") }
-{ "id": 20, "date": date("2011-01-27-05:00"), "time": time("17:20:30.999Z"), "datetime": datetime("1951-12-27T12:20:30.240-08:45"), "duration": duration("D0Y10M15DT10H0M50S") }
-{ "id": 30, "date": date("-2011-01-27-05:00"), "time": time("12:20:30.999Z"), "datetime": datetime("-1951-12-27T12:20:30.240-08:15"), "duration": duration("-D0Y0M0DT0H0M50S") }
-{ "id": 40, "date": date("-2011-01-27+00:00"), "time": time("12:20:30.000Z"), "datetime": datetime("-1951-12-27T12:20:30.240+00:00"), "duration": duration("-D0Y10M0DT0H0M0S") }
+{ "id": 10, "date": date("2011-01-27+00:00"), "time": time("12:20:30.000Z"), "datetime": datetime("1951-12-27T12:20:30.000+00:00"), "duration": duration("P30Y10M15DT10H30M50S") }
+{ "id": 20, "date": date("2011-01-27-05:00"), "time": time("17:20:30.999Z"), "datetime": datetime("1951-12-27T12:20:30.240-08:45"), "duration": duration("P0Y10M15DT10H0M50S") }
+{ "id": 30, "date": date("-2011-01-27-05:00"), "time": time("12:20:30.999Z"), "datetime": datetime("-1951-12-27T12:20:30.240-08:15"), "duration": duration("-P0Y0M0DT0H0M50S") }
+{ "id": 40, "date": date("-2011-01-27+00:00"), "time": time("12:20:30.000Z"), "datetime": datetime("-1951-12-27T12:20:30.240+00:00"), "duration": duration("-P0Y10M0DT0H0M0S") }
diff --git a/asterix-om/src/main/java/edu/uci/ics/asterix/dataflow/data/nontagged/printers/ADatePrinter.java b/asterix-om/src/main/java/edu/uci/ics/asterix/dataflow/data/nontagged/printers/ADatePrinter.java
index e9f887e..0895630 100644
--- a/asterix-om/src/main/java/edu/uci/ics/asterix/dataflow/data/nontagged/printers/ADatePrinter.java
+++ b/asterix-om/src/main/java/edu/uci/ics/asterix/dataflow/data/nontagged/printers/ADatePrinter.java
@@ -2,13 +2,17 @@
 
 import java.io.PrintStream;
 
-import edu.uci.ics.asterix.dataflow.data.nontagged.serde.AInt16SerializerDeserializer;
+import edu.uci.ics.asterix.dataflow.data.nontagged.serde.AInt32SerializerDeserializer;
+import edu.uci.ics.asterix.om.base.temporal.GregorianCalendarSystem;
 import edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException;
 import edu.uci.ics.hyracks.algebricks.data.IPrinter;
 
 public class ADatePrinter implements IPrinter {
 
     private static final long serialVersionUID = 1L;
+
+    private static long CHRONON_OF_DAY = 24 * 60 * 60 * 1000;
+
     public static final ADatePrinter INSTANCE = new ADatePrinter();
 
     @Override
@@ -18,11 +22,23 @@
 
     @Override
     public void print(byte[] b, int s, int l, PrintStream ps) throws AlgebricksException {
-        int year = AInt16SerializerDeserializer.getShort(b, s + 1) >> 1;
-        int month = (AInt16SerializerDeserializer.getShort(b, s + 1) & 0x0001) * 8 + ((b[s + 3] >> 5) & 0x07);
-        int day = b[s + 3] & 0x1f;
-        byte timezone = b[s + 4];
-        ps.format("date(\"" + (year < 0 ? "%+05d" : "%04d") + "-%02d-%02d%+03d:%02d\")", year, month, day,
-                timezone / 4, timezone % 4 * ((timezone >= 0) ? 15 : -15));
+        long chrononTime = AInt32SerializerDeserializer.getInt(b, s + 1) * CHRONON_OF_DAY;
+
+        GregorianCalendarSystem calendar = GregorianCalendarSystem.getInstance();
+
+        int year = calendar.getYear(chrononTime);
+        int month = calendar.getMonthOfYear(chrononTime, year);
+
+        ps.print("date(\"");
+        ps.append(String.format(year < 0 ? "%05d" : "%04d", year)).append("-").append(String.format("%02d", month))
+                .append("-").append(String.format("%02d", calendar.getDayOfMonthYear(chrononTime, year, month)))
+                .append("Z");
+        ps.print("\")");
+        //        int year = AInt16SerializerDeserializer.getShort(b, s + 1) >> 1;
+        //        int month = (AInt16SerializerDeserializer.getShort(b, s + 1) & 0x0001) * 8 + ((b[s + 3] >> 5) & 0x07);
+        //        int day = b[s + 3] & 0x1f;
+        //        byte timezone = b[s + 4];
+        //        ps.format("date(\"" + (year < 0 ? "%+05d" : "%04d") + "-%02d-%02d%+03d:%02d\")", year, month, day,
+        //                timezone / 4, timezone % 4 * ((timezone >= 0) ? 15 : -15));
     }
 }
\ No newline at end of file
diff --git a/asterix-om/src/main/java/edu/uci/ics/asterix/dataflow/data/nontagged/printers/ADurationPrinter.java b/asterix-om/src/main/java/edu/uci/ics/asterix/dataflow/data/nontagged/printers/ADurationPrinter.java
index 1c4e302..1b141b3 100644
--- a/asterix-om/src/main/java/edu/uci/ics/asterix/dataflow/data/nontagged/printers/ADurationPrinter.java
+++ b/asterix-om/src/main/java/edu/uci/ics/asterix/dataflow/data/nontagged/printers/ADurationPrinter.java
@@ -4,6 +4,7 @@
 import java.io.PrintStream;
 
 import edu.uci.ics.asterix.dataflow.data.nontagged.serde.AInt32SerializerDeserializer;
+import edu.uci.ics.asterix.dataflow.data.nontagged.serde.AInt64SerializerDeserializer;
 import edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException;
 import edu.uci.ics.hyracks.algebricks.data.IPrinter;
 import edu.uci.ics.hyracks.algebricks.data.utils.WriteValueTools;
@@ -22,27 +23,28 @@
     public void print(byte[] b, int s, int l, PrintStream ps) throws AlgebricksException {
         boolean positive = true;
         int months = AInt32SerializerDeserializer.getInt(b, s + 1);
-        int seconds = AInt32SerializerDeserializer.getInt(b, s + 5);
+        long milliseconds = AInt64SerializerDeserializer.getLong(b, s + 5);
 
-        if (months < 0 || seconds < 0) {
+        if (months < 0 || milliseconds < 0) {
             months *= -1;
-            seconds *= -1;
+            milliseconds *= -1;
             positive = false;
         }
 
         int month = (int) (months % 12);
         int year = (int) (months / 12);
-        int second = (int) (seconds % 60);
-        int minute = (int) (seconds % 3600 / 60);
-        int hour = (int) (seconds % (86400) / 3600);
-        int day = (int) (seconds / (86400));
+        int millisecond = (int) (milliseconds % 1000);
+        int second = (int) (milliseconds % 60000 / 1000);
+        int minute = (int) (milliseconds % 3600000 / 60000);
+        int hour = (int) (milliseconds % (86400000) / 3600000);
+        int day = (int) (milliseconds / (86400000));
 
         ps.print("duration(\"");
         if (!positive) {
             ps.print("-");
         }
         try {
-            ps.print("D");
+            ps.print("P");
             WriteValueTools.writeInt(year, ps);
             ps.print("Y");
             WriteValueTools.writeInt(month, ps);
@@ -54,6 +56,10 @@
             WriteValueTools.writeInt(minute, ps);
             ps.print("M");
             WriteValueTools.writeInt(second, ps);
+            if (millisecond > 0) {
+                ps.print(".");
+                WriteValueTools.writeInt(millisecond, ps);
+            }
             ps.print("S\")");
         } catch (IOException e) {
             throw new AlgebricksException(e);
diff --git a/asterix-om/src/main/java/edu/uci/ics/asterix/dataflow/data/nontagged/serde/ADateSerializerDeserializer.java b/asterix-om/src/main/java/edu/uci/ics/asterix/dataflow/data/nontagged/serde/ADateSerializerDeserializer.java
index 6a0e8cd..92019e9 100644
--- a/asterix-om/src/main/java/edu/uci/ics/asterix/dataflow/data/nontagged/serde/ADateSerializerDeserializer.java
+++ b/asterix-om/src/main/java/edu/uci/ics/asterix/dataflow/data/nontagged/serde/ADateSerializerDeserializer.java
@@ -7,6 +7,7 @@
 import edu.uci.ics.asterix.formats.nontagged.AqlSerializerDeserializerProvider;
 import edu.uci.ics.asterix.om.base.ADate;
 import edu.uci.ics.asterix.om.base.AMutableDate;
+import edu.uci.ics.asterix.om.base.temporal.GregorianCalendarSystem;
 import edu.uci.ics.asterix.om.types.BuiltinType;
 import edu.uci.ics.hyracks.api.dataflow.value.ISerializerDeserializer;
 import edu.uci.ics.hyracks.api.exceptions.HyracksDataException;
@@ -14,15 +15,15 @@
 public class ADateSerializerDeserializer implements ISerializerDeserializer<ADate> {
 
     private static final long serialVersionUID = 1L;
-    private short year;
-    private byte monthAndDay;
+
+    private int chrononTimeInDays;
 
     public static final ADateSerializerDeserializer INSTANCE = new ADateSerializerDeserializer();
     @SuppressWarnings("unchecked")
     private static ISerializerDeserializer<ADate> dateSerde = AqlSerializerDeserializerProvider.INSTANCE
             .getSerializerDeserializer(BuiltinType.ADATE);
-    private static AMutableDate aDate = new AMutableDate(0, 0, 0, 0);
-    private static String errorMessage = " can not be an instance of date";
+    private static AMutableDate aDate = new AMutableDate(0);
+    private static final String errorMessage = "This can not be an instance of date";
 
     private ADateSerializerDeserializer() {
     }
@@ -30,10 +31,8 @@
     @Override
     public ADate deserialize(DataInput in) throws HyracksDataException {
         try {
-            year = in.readShort();
-            monthAndDay = in.readByte();
-            return new ADate(year >> 1, (year & 0x0001) * 8 + ((monthAndDay >> 5) & 0x07), monthAndDay & 0x1f,
-                    in.readByte());
+            chrononTimeInDays = in.readInt();
+            return new ADate(chrononTimeInDays);
         } catch (IOException e) {
             throw new HyracksDataException(e);
         }
@@ -42,60 +41,215 @@
     @Override
     public void serialize(ADate instance, DataOutput out) throws HyracksDataException {
         try {
-            out.writeByte((byte) ((instance.getYear() << 1) >> 8));
-            out.writeByte((byte) ((byte) ((instance.getYear() << 1) & 0x00ff) + (byte) (instance.getMonth() >> 3)));
-            out.writeByte((byte) (((byte) (instance.getMonth() << 5)) | ((byte) instance.getDay())));
-            out.writeByte((byte) instance.getTimeZone());
+            out.writeInt(instance.getChrononTimeInDays());
         } catch (IOException e) {
             throw new HyracksDataException(e);
         }
     }
 
     public static void parse(String date, DataOutput out) throws HyracksDataException {
-        int offset = 0;
-        boolean positive = true;
-        byte timezonePart = 0;
-        if (date.charAt(0) == '-') {
-            positive = false;
-            offset++;
-        }
-
-        if (date.charAt(offset + 4) != '-' || date.charAt(offset + 7) != '-')
-            throw new HyracksDataException(date + errorMessage);
-        short year = Short.parseShort(date.substring(offset, offset + 4));
-        short month = Short.parseShort(date.substring(offset + 5, offset + 7));
-        short day = Short.parseShort(date.substring(offset + 8, offset + 10));
-        short hour, minute;
-        if (year < 0 || year > 9999 || month < 0 || month > 12 || day < 0 || day > 31)
-            throw new HyracksDataException(date + errorMessage);
-
-        offset += 10;
-
-        if (date.length() > offset) {
-            if (date.charAt(offset) == 'Z')
-                timezonePart = 0;
-            else {
-                if ((date.charAt(offset) != '+' && date.charAt(offset) != '-') || (date.charAt(offset + 3) != ':'))
-                    throw new HyracksDataException(date + errorMessage);
-
-                hour = Short.parseShort(date.substring(offset + 1, offset + 3));
-                minute = Short.parseShort(date.substring(offset + 4, offset + 6));
-
-                if (hour < 0 || hour > 24 || (hour == 24 && minute != 0)
-                        || (minute != 0 && minute != 15 && minute != 30 && minute != 45))
-                    throw new HyracksDataException(date + errorMessage);
-
-                if (date.charAt(offset) == '-')
-                    timezonePart = (byte) -((hour * 4) + minute / 15);
-                else
-                    timezonePart = (byte) ((hour * 4) + minute / 15);
-            }
-
-        }
-        if (!positive)
-            year *= -1;
-        aDate.setValue(year, month, day, timezonePart);
+        parseString(date);
         dateSerde.serialize(aDate, out);
     }
 
+    private static void parseString(String date) throws HyracksDataException {
+        int year = 0, month = 0, day = 0;
+        int timezone = 0;
+        int offset = 0;
+        boolean positive = true;
+        if (date.charAt(offset + 4) == '-' || date.charAt(offset + 5) == '-') {
+            // parse extended form
+            if (date.charAt(offset) == '-') {
+                offset++;
+                positive = false;
+            }
+
+            if (date.charAt(offset + 4) != '-' || date.charAt(offset + 7) != '-')
+                throw new HyracksDataException(errorMessage);
+
+            // year
+            for (int i = 0; i < 4; i++) {
+                if ((date.charAt(offset + i) >= '0' && date.charAt(offset + i) <= '9')) {
+                    year = year * 10 + date.charAt(offset + i) - '0';
+                } else {
+                    throw new HyracksDataException(errorMessage);
+                }
+            }
+
+            if (year < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.YEAR]
+                    || year > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.YEAR]) {
+                throw new HyracksDataException(errorMessage + ": year " + year);
+            }
+
+            offset += 5;
+
+            // month
+            for (int i = 0; i < 2; i++) {
+                if ((date.charAt(offset + i) >= '0' && date.charAt(offset + i) <= '9')) {
+                    month = month * 10 + date.charAt(offset + i) - '0';
+                } else {
+                    throw new HyracksDataException(errorMessage);
+                }
+            }
+
+            if (month < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.MONTH]
+                    || month > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.MONTH]) {
+                throw new HyracksDataException(errorMessage + ": month " + month);
+            }
+
+            offset += 3;
+
+            // day
+            for (int i = 0; i < 2; i++) {
+                if ((date.charAt(offset + i) >= '0' && date.charAt(offset + i) <= '9')) {
+                    day = day * 10 + date.charAt(offset + i) - '0';
+                } else {
+                    throw new HyracksDataException(errorMessage);
+                }
+            }
+
+            if (day < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.DAY]
+                    || day > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.DAY]) {
+                throw new HyracksDataException(errorMessage + ": day " + day);
+            }
+
+            offset += 2;
+
+            if (!positive)
+                year *= -1;
+
+            if (date.length() > offset) {
+                if (date.charAt(offset) != 'Z') {
+                    if ((date.charAt(offset) != '+' && date.charAt(offset) != '-') || (date.charAt(offset + 3) != ':'))
+                        throw new HyracksDataException(errorMessage);
+
+                    short timezoneHour = 0;
+                    short timezoneMinute = 0;
+
+                    for (int i = 0; i < 2; i++) {
+                        if ((date.charAt(offset + 1 + i) >= '0' && date.charAt(offset + 1 + i) <= '9'))
+                            timezoneHour = (short) (timezoneHour * 10 + date.charAt(offset + 1 + i) - '0');
+                        else
+                            throw new HyracksDataException(errorMessage);
+
+                    }
+
+                    for (int i = 0; i < 2; i++) {
+                        if ((date.charAt(offset + 4 + i) >= '0' && date.charAt(offset + 4 + i) <= '9'))
+                            timezoneMinute = (short) (timezoneMinute * 10 + date.charAt(offset + 4 + i) - '0');
+                        else
+                            throw new HyracksDataException(errorMessage);
+
+                        if (date.charAt(offset) == '-')
+                            timezone = (byte) -((timezoneHour * 4) + timezoneMinute / 15);
+                        else
+                            timezone = (byte) ((timezoneHour * 4) + timezoneMinute / 15);
+                    }
+                }
+            }
+
+        } else {
+            // parse basic form
+            if (date.charAt(offset) == '-') {
+                offset++;
+                positive = false;
+            }
+
+            // year
+            for (int i = 0; i < 4; i++) {
+                if ((date.charAt(offset + i) >= '0' && date.charAt(offset + i) <= '9')) {
+                    year = year * 10 + date.charAt(offset + i) - '0';
+                } else {
+                    throw new HyracksDataException(errorMessage);
+                }
+            }
+
+            if (year < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.YEAR]
+                    || year > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.YEAR]) {
+                throw new HyracksDataException(errorMessage + ": year " + year);
+            }
+
+            offset += 4;
+
+            // month
+            for (int i = 0; i < 2; i++) {
+                if ((date.charAt(offset + i) >= '0' && date.charAt(offset + i) <= '9')) {
+                    month = month * 10 + date.charAt(offset + i) - '0';
+                } else {
+                    throw new HyracksDataException(errorMessage);
+                }
+            }
+
+            if (month < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.MONTH]
+                    || month > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.MONTH]) {
+                throw new HyracksDataException(errorMessage + ": month " + month);
+            }
+
+            offset += 2;
+
+            // day
+            for (int i = 0; i < 2; i++) {
+                if ((date.charAt(offset + i) >= '0' && date.charAt(offset + i) <= '9')) {
+                    day = day * 10 + date.charAt(offset + i) - '0';
+                } else {
+                    throw new HyracksDataException(errorMessage);
+                }
+            }
+
+            if (day < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.DAY]
+                    || day > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.DAY]) {
+                throw new HyracksDataException(errorMessage + ": day " + day);
+            }
+
+            offset += 2;
+
+            if (!positive)
+                year *= -1;
+
+            if (date.length() > offset) {
+                if (date.charAt(offset) != 'Z') {
+                    if ((date.charAt(offset) != '+' && date.charAt(offset) != '-'))
+                        throw new HyracksDataException(errorMessage);
+
+                    short timezoneHour = 0;
+                    short timezoneMinute = 0;
+
+                    for (int i = 0; i < 2; i++) {
+                        if (date.charAt(offset + 1 + i) >= '0' && date.charAt(offset + 1 + i) <= '9')
+                            timezoneHour = (short) (timezoneHour * 10 + date.charAt(offset + 1 + i) - '0');
+                        else
+                            throw new HyracksDataException(errorMessage);
+
+                    }
+
+                    if (timezoneHour < GregorianCalendarSystem.TIMEZONE_HOUR_MIN
+                            || timezoneHour > GregorianCalendarSystem.TIMEZONE_HOUR_MAX) {
+                        throw new HyracksDataException(errorMessage + ": time zone hour " + timezoneHour);
+                    }
+
+                    for (int i = 0; i < 2; i++) {
+                        if (date.charAt(offset + 3 + i) >= '0' && date.charAt(offset + 3 + i) <= '9')
+                            timezoneMinute = (short) (timezoneMinute * 10 + date.charAt(offset + 3 + i) - '0');
+                        else
+                            throw new HyracksDataException(errorMessage);
+                    }
+
+                    if (timezoneMinute < GregorianCalendarSystem.TIMEZONE_MIN_MIN
+                            || timezoneMinute > GregorianCalendarSystem.TIMEZONE_MIN_MAX) {
+                        throw new HyracksDataException(errorMessage + ": time zone minute " + timezoneMinute);
+                    }
+
+                    if (date.charAt(offset) == '-')
+                        timezone = (byte) -((timezoneHour * 4) + timezoneMinute / 15);
+                    else
+                        timezone = (byte) ((timezoneHour * 4) + timezoneMinute / 15);
+                }
+            }
+        }
+
+        long chrononTimeInMs = GregorianCalendarSystem.getInstance().getChronon(year, month, day, 0, 0, 0, 0, timezone);
+        aDate.setValue((int) (chrononTimeInMs / GregorianCalendarSystem.CHRONON_OF_DAY));
+        if (chrononTimeInMs < 0 && chrononTimeInMs % GregorianCalendarSystem.CHRONON_OF_DAY != 0)
+            aDate.setValue((int) (chrononTimeInMs / GregorianCalendarSystem.CHRONON_OF_DAY) - 1);
+    }
 }
diff --git a/asterix-om/src/main/java/edu/uci/ics/asterix/dataflow/data/nontagged/serde/ADateTimeSerializerDeserializer.java b/asterix-om/src/main/java/edu/uci/ics/asterix/dataflow/data/nontagged/serde/ADateTimeSerializerDeserializer.java
index 75194c6..975b9d0 100644
--- a/asterix-om/src/main/java/edu/uci/ics/asterix/dataflow/data/nontagged/serde/ADateTimeSerializerDeserializer.java
+++ b/asterix-om/src/main/java/edu/uci/ics/asterix/dataflow/data/nontagged/serde/ADateTimeSerializerDeserializer.java
@@ -21,6 +21,7 @@
     private static ISerializerDeserializer<ADateTime> datetimeSerde = AqlSerializerDeserializerProvider.INSTANCE
             .getSerializerDeserializer(BuiltinType.ADATETIME);
     private static AMutableDateTime aDateTime = new AMutableDateTime(0L);
+    private static final String errorMessage = "This can not be an instance of datetime";
 
     private long chrononTime;
 
@@ -48,7 +49,373 @@
     }
 
     public static void parse(String datetime, DataOutput out) throws HyracksDataException {
-        GregorianCalendarSystem.getInstance().parseStringForADatetime(datetime, aDateTime);
+        parseString(datetime);
         datetimeSerde.serialize(aDateTime, out);
     }
+
+    private static void parseString(String datetime) throws HyracksDataException {
+        int year = 0, month = 0, day = 0, hour = 0, min = 0, sec = 0, millis = 0;
+        int timezone = 0;
+
+        int offset = 0;
+
+        boolean positive = true;
+        boolean isExtendedForm = false;
+        if (datetime.charAt(offset + 13) == ':' || datetime.charAt(offset + 14) == ':') {
+            isExtendedForm = true;
+        }
+        if (isExtendedForm) {
+            // parse extended form
+            if (datetime.charAt(offset) == '-') {
+                offset++;
+                positive = false;
+            }
+
+            if (datetime.charAt(offset + 4) != '-' || datetime.charAt(offset + 7) != '-')
+                throw new HyracksDataException(errorMessage);
+
+            // year
+            for (int i = 0; i < 4; i++) {
+                if ((datetime.charAt(offset + i) >= '0' && datetime.charAt(offset + i) <= '9')) {
+                    year = year * 10 + datetime.charAt(offset + i) - '0';
+                } else {
+                    throw new HyracksDataException(errorMessage);
+                }
+            }
+
+            if (year < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.YEAR]
+                    || year > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.YEAR]) {
+                throw new HyracksDataException(errorMessage + ": year " + year);
+            }
+
+            offset += 5;
+
+            // month
+            for (int i = 0; i < 2; i++) {
+                if ((datetime.charAt(offset + i) >= '0' && datetime.charAt(offset + i) <= '9')) {
+                    month = month * 10 + datetime.charAt(offset + i) - '0';
+                } else {
+                    throw new HyracksDataException(errorMessage);
+                }
+            }
+
+            if (month < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.MONTH]
+                    || month > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.MONTH]) {
+                throw new HyracksDataException(errorMessage + ": month " + month);
+            }
+
+            offset += 3;
+
+            // day
+            for (int i = 0; i < 2; i++) {
+                if ((datetime.charAt(offset + i) >= '0' && datetime.charAt(offset + i) <= '9')) {
+                    day = day * 10 + datetime.charAt(offset + i) - '0';
+                } else {
+                    throw new HyracksDataException(errorMessage);
+                }
+            }
+
+            if (day < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.DAY]
+                    || day > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.DAY]) {
+                throw new HyracksDataException(errorMessage + ": day " + day);
+            }
+
+            offset += 2;
+
+            if (!positive)
+                year *= -1;
+
+            // skip the "T" separator
+            offset += 1;
+
+            if (datetime.charAt(offset + 2) != ':' || datetime.charAt(offset + 5) != ':')
+                throw new HyracksDataException(errorMessage);
+
+            // hour
+            for (int i = 0; i < 2; i++) {
+                if ((datetime.charAt(offset + i) >= '0' && datetime.charAt(offset + i) <= '9')) {
+                    hour = hour * 10 + datetime.charAt(offset + i) - '0';
+                } else {
+                    throw new HyracksDataException(errorMessage);
+                }
+            }
+
+            if (hour < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.HOUR]
+                    || hour > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.HOUR]) {
+                throw new HyracksDataException(errorMessage + ": hour " + hour);
+            }
+
+            offset += 3;
+
+            // minute
+            for (int i = 0; i < 2; i++) {
+                if ((datetime.charAt(offset + i) >= '0' && datetime.charAt(offset + i) <= '9')) {
+                    min = min * 10 + datetime.charAt(offset + i) - '0';
+                } else {
+                    throw new HyracksDataException(errorMessage);
+                }
+            }
+
+            if (min < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.MINUTE]
+                    || min > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.MINUTE]) {
+                throw new HyracksDataException(errorMessage + ": min " + min);
+            }
+
+            offset += 3;
+
+            // second
+            for (int i = 0; i < 2; i++) {
+                if ((datetime.charAt(offset + i) >= '0' && datetime.charAt(offset + i) <= '9')) {
+                    sec = sec * 10 + datetime.charAt(offset + i) - '0';
+                } else {
+                    throw new HyracksDataException(errorMessage);
+                }
+            }
+
+            if (sec < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.SECOND]
+                    || sec > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.SECOND]) {
+                throw new HyracksDataException(errorMessage + ": sec " + sec);
+            }
+
+            offset += 2;
+
+            if (datetime.length() > offset && datetime.charAt(offset) == '.') {
+
+                offset++;
+                int i = 0;
+                for (; i < 3 && offset + i < datetime.length(); i++) {
+                    if (datetime.charAt(offset + i) >= '0' && datetime.charAt(offset + i) <= '9') {
+                        millis = millis * 10 + datetime.charAt(offset + i) - '0';
+                    } else {
+                        break;
+                    }
+                }
+
+                offset += i;
+
+                for (; i < 3; i++) {
+                    millis = millis * 10;
+                }
+
+                for (; offset < datetime.length(); offset++) {
+                    if (datetime.charAt(offset) < '0' || datetime.charAt(offset) > '9') {
+                        break;
+                    }
+                }
+            }
+
+            if (datetime.length() > offset) {
+                if (datetime.charAt(offset) != 'Z') {
+                    if ((datetime.charAt(offset) != '+' && datetime.charAt(offset) != '-')
+                            || (datetime.charAt(offset + 3) != ':'))
+                        throw new HyracksDataException(errorMessage);
+
+                    short timezoneHour = 0;
+                    short timezoneMinute = 0;
+
+                    for (int i = 0; i < 2; i++) {
+                        if ((datetime.charAt(offset + 1 + i) >= '0' && datetime.charAt(offset + 1 + i) <= '9'))
+                            timezoneHour = (short) (timezoneHour * 10 + datetime.charAt(offset + 1 + i) - '0');
+                        else
+                            throw new HyracksDataException(errorMessage);
+
+                    }
+
+                    if (timezoneHour < GregorianCalendarSystem.TIMEZONE_HOUR_MIN
+                            || timezoneHour > GregorianCalendarSystem.TIMEZONE_HOUR_MAX) {
+                        throw new HyracksDataException(errorMessage + ": time zone hour " + timezoneHour);
+                    }
+
+                    for (int i = 0; i < 2; i++) {
+                        if ((datetime.charAt(offset + 4 + i) >= '0' && datetime.charAt(offset + 4 + i) <= '9'))
+                            timezoneMinute = (short) (timezoneMinute * 10 + datetime.charAt(offset + 4 + i) - '0');
+                        else
+                            throw new HyracksDataException(errorMessage);
+                    }
+
+                    if (timezoneMinute < GregorianCalendarSystem.TIMEZONE_MIN_MIN
+                            || timezoneMinute > GregorianCalendarSystem.TIMEZONE_MIN_MAX) {
+                        throw new HyracksDataException(errorMessage + ": time zone minute " + timezoneMinute);
+                    }
+
+                    if (datetime.charAt(offset) == '-')
+                        timezone = (byte) -((timezoneHour * 4) + timezoneMinute / 15);
+                    else
+                        timezone = (byte) ((timezoneHour * 4) + timezoneMinute / 15);
+                }
+            }
+
+        } else {
+            // parse basic form
+            if (datetime.charAt(offset) == '-') {
+                offset++;
+                positive = false;
+            }
+
+            // year
+            for (int i = 0; i < 4; i++) {
+                if ((datetime.charAt(offset + i) >= '0' && datetime.charAt(offset + i) <= '9')) {
+                    year = year * 10 + datetime.charAt(offset + i) - '0';
+                } else {
+                    throw new HyracksDataException(errorMessage);
+                }
+            }
+
+            if (year < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.YEAR]
+                    || year > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.YEAR]) {
+                throw new HyracksDataException(errorMessage + ": year " + year);
+            }
+
+            offset += 4;
+
+            // month
+            for (int i = 0; i < 2; i++) {
+                if ((datetime.charAt(offset + i) >= '0' && datetime.charAt(offset + i) <= '9')) {
+                    month = month * 10 + datetime.charAt(offset + i) - '0';
+                } else {
+                    throw new HyracksDataException(errorMessage);
+                }
+            }
+
+            if (month < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.MONTH]
+                    || month > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.MONTH]) {
+                throw new HyracksDataException(errorMessage + ": month " + month);
+            }
+
+            offset += 2;
+
+            // day
+            for (int i = 0; i < 2; i++) {
+                if ((datetime.charAt(offset + i) >= '0' && datetime.charAt(offset + i) <= '9')) {
+                    day = day * 10 + datetime.charAt(offset + i) - '0';
+                } else {
+                    throw new HyracksDataException(errorMessage);
+                }
+            }
+
+            if (day < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.DAY]
+                    || day > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.DAY]) {
+                throw new HyracksDataException(errorMessage + ": day " + day);
+            }
+
+            offset += 2;
+
+            if (!positive)
+                year *= -1;
+
+            // hour
+            for (int i = 0; i < 2; i++) {
+                if ((datetime.charAt(offset + i) >= '0' && datetime.charAt(offset + i) <= '9')) {
+                    hour = hour * 10 + datetime.charAt(offset + i) - '0';
+                } else {
+                    throw new HyracksDataException(errorMessage);
+                }
+            }
+
+            if (hour < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.HOUR]
+                    || hour > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.HOUR]) {
+                throw new HyracksDataException(errorMessage + ": hour " + hour);
+            }
+
+            offset += 2;
+
+            // minute
+            for (int i = 0; i < 2; i++) {
+                if ((datetime.charAt(offset + i) >= '0' && datetime.charAt(offset + i) <= '9')) {
+                    min = min * 10 + datetime.charAt(offset + i) - '0';
+                } else {
+                    throw new HyracksDataException(errorMessage);
+                }
+            }
+
+            if (min < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.MINUTE]
+                    || min > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.MINUTE]) {
+                throw new HyracksDataException(errorMessage + ": min " + min);
+            }
+
+            offset += 2;
+
+            // second
+            for (int i = 0; i < 2; i++) {
+                if ((datetime.charAt(offset + i) >= '0' && datetime.charAt(offset + i) <= '9')) {
+                    sec = sec * 10 + datetime.charAt(offset + i) - '0';
+                } else {
+                    throw new HyracksDataException(errorMessage);
+                }
+            }
+
+            if (sec < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.SECOND]
+                    || sec > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.SECOND]) {
+                throw new HyracksDataException(errorMessage + ": sec " + sec);
+            }
+
+            offset += 2;
+
+            if (datetime.length() > offset) {
+                int i = 0;
+                for (; i < 3 && offset + i < datetime.length(); i++) {
+                    if (datetime.charAt(offset + i) >= '0' && datetime.charAt(offset + i) <= '9') {
+                        millis = millis * 10 + datetime.charAt(offset + i) - '0';
+                    } else {
+                        break;
+                    }
+                }
+
+                offset += i;
+
+                for (; i < 3; i++) {
+                    millis = millis * 10;
+                }
+
+                for (; offset < datetime.length(); offset++) {
+                    if (datetime.charAt(offset) < '0' || datetime.charAt(offset) > '9') {
+                        break;
+                    }
+                }
+            }
+
+            if (datetime.length() > offset) {
+                if (datetime.charAt(offset) != 'Z') {
+                    if ((datetime.charAt(offset) != '+' && datetime.charAt(offset) != '-'))
+                        throw new HyracksDataException(errorMessage);
+
+                    short timezoneHour = 0;
+                    short timezoneMinute = 0;
+
+                    for (int i = 0; i < 2; i++) {
+                        if ((datetime.charAt(offset + 1 + i) >= '0' && datetime.charAt(offset + 1 + i) <= '9'))
+                            timezoneHour = (short) (timezoneHour * 10 + datetime.charAt(offset + 1 + i) - '0');
+                        else
+                            throw new HyracksDataException(errorMessage);
+
+                    }
+
+                    if (timezoneHour < GregorianCalendarSystem.TIMEZONE_HOUR_MIN
+                            || timezoneHour > GregorianCalendarSystem.TIMEZONE_HOUR_MAX) {
+                        throw new HyracksDataException(errorMessage + ": time zone hour " + timezoneHour);
+                    }
+
+                    for (int i = 0; i < 2; i++) {
+                        if ((datetime.charAt(offset + 3 + i) >= '0' && datetime.charAt(offset + 3 + i) <= '9'))
+                            timezoneMinute = (short) (timezoneMinute * 10 + datetime.charAt(offset + 3 + i) - '0');
+                        else
+                            throw new HyracksDataException(errorMessage);
+                    }
+
+                    if (timezoneMinute < GregorianCalendarSystem.TIMEZONE_MIN_MIN
+                            || timezoneMinute > GregorianCalendarSystem.TIMEZONE_MIN_MAX) {
+                        throw new HyracksDataException(errorMessage + ": time zone minute " + timezoneMinute);
+                    }
+
+                    if (datetime.charAt(offset) == '-')
+                        timezone = (byte) -((timezoneHour * 4) + timezoneMinute / 15);
+                    else
+                        timezone = (byte) ((timezoneHour * 4) + timezoneMinute / 15);
+                }
+            }
+        }
+
+        aDateTime.setValue(GregorianCalendarSystem.getInstance().getChronon(year, month, day, hour, min, sec,
+                (int) millis, timezone));
+    }
 }
diff --git a/asterix-om/src/main/java/edu/uci/ics/asterix/dataflow/data/nontagged/serde/ADurationSerializerDeserializer.java b/asterix-om/src/main/java/edu/uci/ics/asterix/dataflow/data/nontagged/serde/ADurationSerializerDeserializer.java
index 134eed6..77d757a 100644
--- a/asterix-om/src/main/java/edu/uci/ics/asterix/dataflow/data/nontagged/serde/ADurationSerializerDeserializer.java
+++ b/asterix-om/src/main/java/edu/uci/ics/asterix/dataflow/data/nontagged/serde/ADurationSerializerDeserializer.java
@@ -29,7 +29,7 @@
     @Override
     public ADuration deserialize(DataInput in) throws HyracksDataException {
         try {
-            return new ADuration(in.readInt(), in.readInt());
+            return new ADuration(in.readInt(), in.readLong());
         } catch (IOException e) {
             throw new HyracksDataException(e);
         }
@@ -39,7 +39,7 @@
     public void serialize(ADuration instance, DataOutput out) throws HyracksDataException {
         try {
             out.writeInt(instance.getMonths());
-            out.writeInt(instance.getSeconds());
+            out.writeLong(instance.getMilliseconds());
         } catch (IOException e) {
             throw new HyracksDataException(e);
         }
@@ -49,8 +49,8 @@
         try {
             boolean positive = true;
             int offset = 0;
-            int value = 0, hour = 0, minute = 0, second = 0, year = 0, month = 0, day = 0;
-            boolean isYear = true, isMonth = true, isDay = true, isHour = true, isMinute = true, isSecond = true;
+            int value = 0, hour = 0, minute = 0, second = 0, millisecond = 0, year = 0, month = 0, day = 0;
+            boolean isYear = true, isMonth = true, isDay = true, isHour = true, isMinute = true, isSecond = true, isMillisecond = true;
             boolean isTime = false;
             boolean timeItem = true;
             if (duration.charAt(offset) == '-') {
@@ -58,11 +58,12 @@
                 positive = false;
             }
 
-            if (duration.charAt(offset++) != 'D')
+            if (duration.charAt(offset++) != 'P')
                 throw new HyracksDataException(duration + errorMessage);
 
             for (; offset < duration.length(); offset++) {
                 if (duration.charAt(offset) >= '0' && duration.charAt(offset) <= '9')
+                    // accumulate the digit fields
                     value = value * 10 + duration.charAt(offset) - '0';
                 else {
                     switch (duration.charAt(offset)) {
@@ -76,33 +77,21 @@
                         case 'M':
                             if (!isTime) {
                                 if (isMonth) {
-                                    if (value < 0 || value > 11)
-                                        throw new HyracksDataException(duration + errorMessage);
-                                    else {
-                                        month = value;
-                                        isMonth = false;
-                                    }
+                                    month = value;
+                                    isMonth = false;
                                 } else
                                     throw new HyracksDataException(duration + errorMessage);
                             } else if (isMinute) {
-                                if (value < 0 || value > 59)
-                                    throw new HyracksDataException(duration + errorMessage);
-                                else {
-                                    minute = value;
-                                    isMinute = false;
-                                    timeItem = false;
-                                }
+                                minute = value;
+                                isMinute = false;
+                                timeItem = false;
                             } else
                                 throw new HyracksDataException(duration + errorMessage);
                             break;
                         case 'D':
                             if (isDay) {
-                                if (value < 0 || value > 30)
-                                    throw new HyracksDataException(duration + errorMessage);
-                                else {
-                                    day = value;
-                                    isDay = false;
-                                }
+                                day = value;
+                                isDay = false;
                             } else
                                 throw new HyracksDataException(duration + errorMessage);
                             break;
@@ -116,25 +105,25 @@
 
                         case 'H':
                             if (isHour) {
-                                if (value < 0 || value > 23)
-                                    throw new HyracksDataException(duration + errorMessage);
-                                else {
-                                    hour = value;
-                                    isHour = false;
-                                    timeItem = false;
-                                }
+                                hour = value;
+                                isHour = false;
+                                timeItem = false;
                             } else
                                 throw new HyracksDataException(duration + errorMessage);
                             break;
                         case 'S':
                             if (isSecond) {
-                                if (value < 0 || value > 59)
-                                    throw new HyracksDataException(duration + errorMessage);
-                                else {
-                                    second = value;
-                                    isSecond = false;
-                                    timeItem = false;
-                                }
+                                second = value;
+                                isSecond = false;
+                                timeItem = false;
+                            } else
+                                throw new HyracksDataException(duration + errorMessage);
+                            break;
+                        case '.':
+                            if (isMillisecond) {
+                                millisecond = value;
+                                isMillisecond = false;
+                                timeItem = false;
                             } else
                                 throw new HyracksDataException(duration + errorMessage);
                             break;
@@ -149,14 +138,18 @@
             if (isTime && timeItem)
                 throw new HyracksDataException(duration + errorMessage);
 
-            if (isYear && isMonth && isDay && !isTime)
-                throw new HyracksDataException(duration + errorMessage);
+            //            if (isYear && isMonth && isDay && !isTime)
+            //                throw new HyracksDataException(duration + errorMessage);
 
             if (positive)
-                aDuration.setValue(year * 12 + month, day * 24 * 3600 + 3600 * hour + 60 * minute + second);
+                aDuration.setValue(year * 12 + month, day * 24 * 3600 * 1000L + 3600 * 1000L * hour + 60 * minute
+                        * 1000L + second * 1000L + millisecond);
             else
-                aDuration.setValue(-1 * (year * 12 + month), -1
-                        * (day * 24 * 3600 + 3600 * hour + 60 * minute + second));
+                aDuration
+                        .setValue(-1 * (year * 12 + month),
+                                -1
+                                        * (day * 24 * 3600 * 1000L + 3600 * 1000L * hour + 60 * minute * 1000L + second
+                                                * 1000L + millisecond));
             durationSerde.serialize(aDuration, out);
         } catch (HyracksDataException e) {
             throw new HyracksDataException(duration + errorMessage);
diff --git a/asterix-om/src/main/java/edu/uci/ics/asterix/dataflow/data/nontagged/serde/ATimeSerializerDeserializer.java b/asterix-om/src/main/java/edu/uci/ics/asterix/dataflow/data/nontagged/serde/ATimeSerializerDeserializer.java
index 021bc0f..81f9327 100644
--- a/asterix-om/src/main/java/edu/uci/ics/asterix/dataflow/data/nontagged/serde/ATimeSerializerDeserializer.java
+++ b/asterix-om/src/main/java/edu/uci/ics/asterix/dataflow/data/nontagged/serde/ATimeSerializerDeserializer.java
@@ -22,7 +22,7 @@
     private static ISerializerDeserializer<ATime> timeSerde = AqlSerializerDeserializerProvider.INSTANCE
             .getSerializerDeserializer(BuiltinType.ATIME);
     private static AMutableTime aTime = new AMutableTime(0);
-    //private static String errorMessage = " can not be an instance of time";
+    private static String errorMessage = "This can not be an instance of time";
 
     private int ora;
 
@@ -33,7 +33,7 @@
     public ATime deserialize(DataInput in) throws HyracksDataException {
         try {
             ora = in.readInt();
-            
+
             return new ATime(ora);
         } catch (IOException e) {
             throw new HyracksDataException(e);
@@ -43,7 +43,7 @@
     @Override
     public void serialize(ATime instance, DataOutput out) throws HyracksDataException {
         try {
-        	out.writeInt(instance.getOra());
+            out.writeInt(instance.getOra());
 
         } catch (IOException e) {
             throw new HyracksDataException(e);
@@ -51,7 +51,237 @@
     }
 
     public static void parse(String time, DataOutput out) throws HyracksDataException {
-    	GregorianCalendarSystem.getInstance().parseStringForATime(time, aTime);
-    	timeSerde.serialize(aTime, out);
+        parseString(time);
+        timeSerde.serialize(aTime, out);
+    }
+
+    private static void parseString(String time) throws HyracksDataException {
+
+        int hour = 0, min = 0, sec = 0, millis = 0;
+        int timezone = 0;
+
+        int offset = 0;
+
+        boolean isExtendedForm = false;
+        if (time.charAt(offset + 2) == ':') {
+            isExtendedForm = true;
+        }
+        if (isExtendedForm) {
+            // parse extended form
+            if (time.charAt(offset) == '-' || time.charAt(offset + 5) != ':')
+                throw new HyracksDataException(errorMessage);
+
+            for (int i = 0; i < 2; i++) {
+                if ((time.charAt(offset + i) >= '0' && time.charAt(offset + i) <= '9'))
+                    hour = hour * 10 + time.charAt(offset + i) - '0';
+                else
+                    throw new HyracksDataException(errorMessage);
+
+            }
+
+            if (hour < 0 || hour > 23) {
+                throw new HyracksDataException(errorMessage + ": hour " + hour);
+            }
+
+            offset += 3;
+
+            for (int i = 0; i < 2; i++) {
+                if ((time.charAt(offset + i) >= '0' && time.charAt(offset + i) <= '9'))
+                    min = min * 10 + time.charAt(offset + i) - '0';
+                else
+                    throw new HyracksDataException(errorMessage);
+
+            }
+
+            if (min < 0 || min > 59) {
+                throw new HyracksDataException(errorMessage + ": min " + min);
+            }
+
+            offset += 3;
+
+            for (int i = 0; i < 2; i++) {
+                if ((time.charAt(offset + i) >= '0' && time.charAt(offset + i) <= '9'))
+                    sec = sec * 10 + time.charAt(offset + i) - '0';
+                else
+                    throw new HyracksDataException(errorMessage);
+
+            }
+
+            if (sec < 0 || sec > 59) {
+                throw new HyracksDataException(errorMessage + ": sec " + sec);
+            }
+
+            offset += 2;
+
+            if (time.length() > offset && time.charAt(offset) == '.') {
+
+                offset++;
+                int i = 0;
+                for (; i < 3 && offset + i < time.length(); i++) {
+                    if (time.charAt(offset + i) >= '0' && time.charAt(offset + i) <= '9') {
+                        millis = millis * 10 + time.charAt(offset + i) - '0';
+                    } else {
+                        break;
+                    }
+                }
+
+                offset += i;
+
+                for (; i < 3; i++) {
+                    millis = millis * 10;
+                }
+
+                for (; offset < time.length(); offset++) {
+                    if (time.charAt(offset) < '0' || time.charAt(offset) > '9') {
+                        break;
+                    }
+                }
+            }
+
+            if (time.length() > offset) {
+                if (time.charAt(offset) != 'Z') {
+                    if ((time.charAt(offset) != '+' && time.charAt(offset) != '-') || (time.charAt(offset + 3) != ':'))
+                        throw new HyracksDataException(errorMessage);
+
+                    short timezoneHour = 0;
+                    short timezoneMinute = 0;
+
+                    for (int i = 0; i < 2; i++) {
+                        if ((time.charAt(offset + 1 + i) >= '0' && time.charAt(offset + 1 + i) <= '9'))
+                            timezoneHour = (short) (timezoneHour * 10 + time.charAt(offset + 1 + i) - '0');
+                        else
+                            throw new HyracksDataException(errorMessage);
+
+                    }
+
+                    if (timezoneHour < GregorianCalendarSystem.TIMEZONE_HOUR_MIN
+                            || timezoneHour > GregorianCalendarSystem.TIMEZONE_HOUR_MAX) {
+                        throw new HyracksDataException(errorMessage + ": time zone hour " + timezoneHour);
+                    }
+
+                    for (int i = 0; i < 2; i++) {
+                        if ((time.charAt(offset + 4 + i) >= '0' && time.charAt(offset + 4 + i) <= '9'))
+                            timezoneMinute = (short) (timezoneMinute * 10 + time.charAt(offset + 4 + i) - '0');
+                        else
+                            throw new HyracksDataException(errorMessage);
+                    }
+
+                    if (timezoneMinute < GregorianCalendarSystem.TIMEZONE_MIN_MIN
+                            || timezoneMinute > GregorianCalendarSystem.TIMEZONE_MIN_MAX) {
+                        throw new HyracksDataException(errorMessage + ": time zone minute " + timezoneMinute);
+                    }
+
+                    if (time.charAt(offset) == '-')
+                        timezone = (byte) -((timezoneHour * 4) + timezoneMinute / 15);
+                    else
+                        timezone = (byte) ((timezoneHour * 4) + timezoneMinute / 15);
+                }
+            }
+
+        } else {
+            // parse basic form
+
+            if (time.charAt(offset) == '-')
+                throw new HyracksDataException(errorMessage);
+
+            for (int i = 0; i < 2; i++) {
+                if ((time.charAt(offset + i) >= '0' && time.charAt(offset + i) <= '9'))
+                    hour = hour * 10 + time.charAt(offset + i) - '0';
+                else
+                    throw new HyracksDataException(errorMessage);
+
+            }
+
+            if (hour < 0 || hour > 23) {
+                throw new HyracksDataException(errorMessage + ": hour " + hour);
+            }
+
+            offset += 2;
+
+            for (int i = 0; i < 2; i++) {
+                if ((time.charAt(offset + i) >= '0' && time.charAt(offset + i) <= '9'))
+                    min = min * 10 + time.charAt(offset + i) - '0';
+                else
+                    throw new HyracksDataException(errorMessage);
+
+            }
+
+            if (min < 0 || min > 59) {
+                throw new HyracksDataException(errorMessage + ": min " + min);
+            }
+
+            offset += 2;
+
+            for (int i = 0; i < 2; i++) {
+                if ((time.charAt(offset + i) >= '0' && time.charAt(offset + i) <= '9'))
+                    sec = sec * 10 + time.charAt(offset + i) - '0';
+                else
+                    throw new HyracksDataException(errorMessage);
+
+            }
+
+            if (sec < 0 || sec > 59) {
+                throw new HyracksDataException(errorMessage + ": sec " + sec);
+            }
+
+            offset += 2;
+
+            if (time.length() > offset) {
+                int i = 0;
+                for (; i < 3 && offset + i < time.length(); i++) {
+                    if ((time.charAt(offset + i) >= '0' && time.charAt(offset + i) <= '9')) {
+                        millis = millis * 10 + time.charAt(offset + i) - '0';
+                    } else {
+                        break;
+                    }
+                }
+
+                offset += i;
+
+                for (; i < 3; i++) {
+                    millis = millis * 10;
+                }
+
+                for (; offset < time.length(); offset++) {
+                    if (time.charAt(offset) < '0' || time.charAt(offset) > '9') {
+                        break;
+                    }
+                }
+            }
+
+            if (time.length() > offset) {
+                if (time.charAt(offset) != 'Z') {
+                    if ((time.charAt(offset) != '+' && time.charAt(offset) != '-'))
+                        throw new HyracksDataException(errorMessage);
+
+                    short timezoneHour = 0;
+                    short timezoneMinute = 0;
+
+                    for (int i = 0; i < 2; i++) {
+                        if ((time.charAt(offset + 1 + i) >= '0' && time.charAt(offset + 1 + i) <= '9'))
+                            timezoneHour = (short) (timezoneHour * 10 + time.charAt(offset + 1 + i) - '0');
+                        else
+                            throw new HyracksDataException(errorMessage);
+
+                    }
+
+                    for (int i = 0; i < 2; i++) {
+                        if ((time.charAt(offset + 3 + i) >= '0' && time.charAt(offset + 3 + i) <= '9'))
+                            timezoneMinute = (short) (timezoneMinute * 10 + time.charAt(offset + 3 + i) - '0');
+                        else
+                            throw new HyracksDataException(errorMessage);
+
+                    }
+
+                    if (time.charAt(offset) == '-')
+                        timezone = (byte) -((timezoneHour * 4) + timezoneMinute / 15);
+                    else
+                        timezone = (byte) ((timezoneHour * 4) + timezoneMinute / 15);
+                }
+            }
+        }
+
+        aTime.setValue(GregorianCalendarSystem.getInstance().getChronon(hour, min, sec, millis, timezone));
+
     }
 }
\ No newline at end of file
diff --git a/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/ADate.java b/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/ADate.java
index f60c908..0eefc98 100644
--- a/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/ADate.java
+++ b/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/ADate.java
@@ -1,38 +1,22 @@
 package edu.uci.ics.asterix.om.base;
 
 import edu.uci.ics.asterix.common.exceptions.AsterixException;
+import edu.uci.ics.asterix.om.base.temporal.GregorianCalendarSystem;
 import edu.uci.ics.asterix.om.types.BuiltinType;
 import edu.uci.ics.asterix.om.types.IAType;
 import edu.uci.ics.asterix.om.visitors.IOMVisitor;
 
+/**
+ * ADate type represents dates in a gregorian calendar system.
+ */
 public class ADate implements IAObject {
 
-    protected int day;
-    protected int month;
-    protected int year;
-    protected int timezone;
+    protected int chrononTimeInDay;
 
-    public ADate(int year, int month, int day, int timezone) {
-        this.day = day;
-        this.month = month;
-        this.year = year;
-        this.timezone = timezone;
-    }
+    private static long CHRONON_OF_DAY = 24 * 60 * 60 * 1000;
 
-    public int getDay() {
-        return day;
-    }
-
-    public int getMonth() {
-        return month;
-    }
-
-    public int getTimeZone() {
-        return timezone;
-    }
-
-    public int getYear() {
-        return year;
+    public ADate(int chrononTimeInDay) {
+        this.chrononTimeInDay = chrononTimeInDay;
     }
 
     public IAType getType() {
@@ -43,14 +27,13 @@
         if (!(o instanceof ADate)) {
             return false;
         } else {
-            ADate d = (ADate) o;
-            return d.getDay() == day && d.getMonth() == month && d.getYear() == year && d.getTimeZone() == timezone;
+            return ((ADate) o).chrononTimeInDay == this.chrononTimeInDay;
         }
     }
 
     @Override
     public int hashCode() {
-        return ((year * 31 + month) * 31 + day) * 31 + timezone;
+        return chrononTimeInDay;
     }
 
     @Override
@@ -70,6 +53,15 @@
 
     @Override
     public String toString() {
-        return "ADate: { " + year + "-" + month + "-" + day + ":" + timezone + " }";
+        StringBuilder sbder = new StringBuilder();
+        sbder.append("ADate: { ");
+        GregorianCalendarSystem.getInstance().getExtendStringRepWithTimezoneUntilField(
+                chrononTimeInDay * CHRONON_OF_DAY, 0, sbder, GregorianCalendarSystem.YEAR, GregorianCalendarSystem.DAY);
+        sbder.append(" }");
+        return sbder.toString();
+    }
+
+    public int getChrononTimeInDays() {
+        return chrononTimeInDay;
     }
 }
diff --git a/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/ADateTime.java b/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/ADateTime.java
index 47ce492..a410bed 100644
--- a/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/ADateTime.java
+++ b/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/ADateTime.java
@@ -6,8 +6,30 @@
 import edu.uci.ics.asterix.om.types.IAType;
 import edu.uci.ics.asterix.om.visitors.IOMVisitor;
 
+/**
+ * ADateTime type represents the timestamp values.
+ * <p/>
+ * An ADateTime value contains the following time fields:<br/>
+ * - year;<br/>
+ * - month;<br/>
+ * - day;<br/>
+ * - hour; <br/>
+ * - minute; <br/>
+ * - second; <br/>
+ * - millisecond. <br/>
+ * By default, an ADateTime value is a UTC time value, i.e., there is no timezone information maintained. However user can use the timezone based AQL function to convert a UTC time to a timezone-embedded time.
+ * <p/>
+ * And the string representation of an ADateTime value follows the ISO8601 standard, in the following format:<br/>
+ * [+|-]YYYY-MM-DDThh:mm:ss.xxxZ
+ * <p/>
+ * Internally, an ADateTime value is stored as the number of milliseconds elapsed since 1970-01-01T00:00:00.000Z (also called chronon time). Functions to convert between a string representation of an ADateTime and its chronon time are implemented in {@link GregorianCalendarSystem}.
+ * <p/>
+ */
 public class ADateTime implements IAObject {
 
+    /**
+     * Represent the time interval as milliseconds since 1970-01-01T00:00:00.000Z.
+     */
     protected long chrononTime;
 
     public ADateTime(long chrononTime) {
@@ -67,7 +89,8 @@
     public String toString() {
         StringBuilder sbder = new StringBuilder();
         sbder.append("ADateTime: { ");
-        GregorianCalendarSystem.getInstance().getStringRep(chrononTime, sbder);
+        GregorianCalendarSystem.getInstance().getExtendStringRepWithTimezoneUntilField(chrononTime, 0, sbder,
+                GregorianCalendarSystem.YEAR, GregorianCalendarSystem.MILLISECOND);
         sbder.append(" }");
         return sbder.toString();
     }
diff --git a/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/ADuration.java b/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/ADuration.java
index 6f8064e..7c60822 100644
--- a/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/ADuration.java
+++ b/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/ADuration.java
@@ -7,20 +7,20 @@
 
 public class ADuration implements IAObject {
 
-    protected int months;
-    protected int seconds;
+    protected int chrononInMonth;
+    protected long chrononInMillisecond;
 
-    public ADuration(int months, int seconds) {
-        this.months = months;
-        this.seconds = seconds;
+    public ADuration(int months, long seconds) {
+        this.chrononInMonth = months;
+        this.chrononInMillisecond = seconds;
     }
 
     public int getMonths() {
-        return months;
+        return chrononInMonth;
     }
 
-    public int getSeconds() {
-        return seconds;
+    public long getMilliseconds() {
+        return chrononInMillisecond;
     }
 
     @Override
@@ -34,13 +34,13 @@
             return false;
         } else {
             ADuration d = (ADuration) o;
-            return d.getMonths() == months && d.getSeconds() == seconds;
+            return d.getMonths() == chrononInMonth && d.getMilliseconds() == chrononInMillisecond;
         }
     }
 
     @Override
     public int hashCode() {
-        return months * 31 + seconds;
+        return (int) (chrononInMonth ^ (chrononInMillisecond) ^ (chrononInMillisecond >>> 32));
     }
 
     @Override
diff --git a/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/AMutableDate.java b/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/AMutableDate.java
index 78a87b8..f6a8e2d 100644
--- a/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/AMutableDate.java
+++ b/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/AMutableDate.java
@@ -2,15 +2,12 @@
 
 public class AMutableDate extends ADate {
 
-    public AMutableDate(int year, int month, int day, int timezone) {
-        super(year, month, day, timezone);
+    public AMutableDate(int chrononTimeInDays) {
+        super(chrononTimeInDays);
     }
 
-    public void setValue(int year, int month, int day, int timezone) {
-        this.year = year;
-        this.month = month;
-        this.day = day;
-        this.timezone = timezone;
+    public void setValue(int chrononTimeInDays) {
+        this.chrononTimeInDay = chrononTimeInDays;
     }
 
 }
diff --git a/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/AMutableDuration.java b/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/AMutableDuration.java
index f776817..367d529 100644
--- a/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/AMutableDuration.java
+++ b/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/AMutableDuration.java
@@ -2,13 +2,13 @@
 
 public class AMutableDuration extends ADuration {
 
-    public AMutableDuration(int months, int seconds) {
-        super(months, seconds);
+    public AMutableDuration(int months, long milliseconds) {
+        super(months, milliseconds);
     }
 
-    public void setValue(int months, int seconds) {
-        this.months = months;
-        this.seconds = seconds;
+    public void setValue(int months, long milliseconds) {
+        this.chrononInMonth = months;
+        this.chrononInMillisecond = milliseconds;
     }
 
 }
diff --git a/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/AMutableTime.java b/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/AMutableTime.java
index c14b075..277479f 100644
--- a/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/AMutableTime.java
+++ b/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/AMutableTime.java
@@ -7,7 +7,7 @@
     }
 
     public void setValue(int ora) {
-        this.ora = ora;
+        this.chrononTime = ora;
     }
 
 }
diff --git a/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/ATime.java b/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/ATime.java
index 3ec2cca..7f6cc1e 100644
--- a/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/ATime.java
+++ b/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/ATime.java
@@ -8,47 +8,47 @@
 
 public class ATime implements IAObject {
 
-    protected int ora;
-    
+    protected int chrononTime;
+
     public ATime(int ora) {
-        this.ora = ora;
+        this.chrononTime = ora;
     }
-    
+
     @Override
     public IAType getType() {
         return BuiltinType.ATIME;
     }
-      
+
     public int compare(Object o) {
         if (!(o instanceof ATime)) {
             return -1;
         }
 
         ATime d = (ATime) o;
-        if (this.ora > d.ora) {
+        if (this.chrononTime > d.chrononTime) {
             return 1;
-        } else if (this.ora < d.ora) {
+        } else if (this.chrononTime < d.chrononTime) {
             return -1;
         } else {
             return 0;
         }
     }
-      
+
     @Override
     public boolean equals(Object o) {
-    	
+
         if (!(o instanceof ATime)) {
             return false;
         } else {
             ATime t = (ATime) o;
-            return t.ora == this.ora;
-            
+            return t.chrononTime == this.chrononTime;
+
         }
     }
 
     @Override
     public int hashCode() {
-    	return ora;
+        return chrononTime;
     }
 
     @Override
@@ -68,16 +68,17 @@
 
     @Override
     public String toString() {
-    	StringBuilder sbder = new StringBuilder();
+        StringBuilder sbder = new StringBuilder();
         sbder.append("ATime: { ");
-        GregorianCalendarSystem.getInstance().getStringRepTime(ora, sbder);
+        GregorianCalendarSystem.getInstance().getExtendStringRepWithTimezoneUntilField(chrononTime, 0, sbder,
+                GregorianCalendarSystem.HOUR, GregorianCalendarSystem.MILLISECOND);
         sbder.append(" }");
         return sbder.toString();
 
     }
-    
+
     public int getOra() {
-    	return ora;
+        return chrononTime;
     }
-    
+
 }
diff --git a/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/temporal/GregorianCalendarSystem.java b/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/temporal/GregorianCalendarSystem.java
index b36ed26..d23773f 100644
--- a/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/temporal/GregorianCalendarSystem.java
+++ b/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/temporal/GregorianCalendarSystem.java
@@ -30,36 +30,28 @@
  */
 package edu.uci.ics.asterix.om.base.temporal;
 
-import java.io.DataOutput;
-import java.io.IOException;
-
-import edu.uci.ics.asterix.om.base.AMutableDateTime;
-import edu.uci.ics.asterix.om.base.AMutableTime;
-import edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException;
-import edu.uci.ics.hyracks.api.exceptions.HyracksDataException;
-
 /**
  * A simple implementation of the Gregorian calendar system.
  * <p/>
  */
 public class GregorianCalendarSystem implements ICalendarSystem {
 
-    private static final int[] DAYS_OF_MONTH_ORDI = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
-    private static final int[] DAYS_OF_MONTH_LEAP = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+    public static final int YEAR = 0, MONTH = 1, DAY = 2, HOUR = 3, MINUTE = 4, SECOND = 5, MILLISECOND = 6;
 
-    private static final int[] DAYS_SINCE_MONTH_BEGIN_ORDI = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
+    public static final int[] DAYS_OF_MONTH_ORDI = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+    public static final int[] DAYS_OF_MONTH_LEAP = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
 
-    private static final String ERROR_FORMAT = ": unrecognizable datetime format.";
+    public static final int[] DAYS_SINCE_MONTH_BEGIN_ORDI = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
 
-    private static final int CHRONON_OF_SECOND = 1000;
-    private static final int CHRONON_OF_MINUTE = 60 * CHRONON_OF_SECOND;
-    private static final int CHRONON_OF_HOUR = 60 * CHRONON_OF_MINUTE;
-    private static final long CHRONON_OF_DAY = 24 * CHRONON_OF_HOUR;
+    public static final int CHRONON_OF_SECOND = 1000;
+    public static final int CHRONON_OF_MINUTE = 60 * CHRONON_OF_SECOND;
+    public static final int CHRONON_OF_HOUR = 60 * CHRONON_OF_MINUTE;
+    public static final long CHRONON_OF_DAY = 24 * CHRONON_OF_HOUR;
 
     /**
      * Minimum feasible value of each field
      */
-    private static final int[] FIELD_MINS = { Integer.MIN_VALUE, // year
+    public static final int[] FIELD_MINS = { Integer.MIN_VALUE, // year
             1, // month
             1, // day
             0, // hour
@@ -68,7 +60,7 @@
             0 // millisecond
     };
 
-    private static final int[] FIELD_MAXS = { Integer.MAX_VALUE, // year
+    public static final int[] FIELD_MAXS = { Integer.MAX_VALUE, // year
             12, // month
             31, // day
             23, // hour
@@ -77,6 +69,9 @@
             999 // millisecond
     };
 
+    public static final int TIMEZONE_HOUR_MIN = -12, TIMEZONE_HOUR_MAX = 14, TIMEZONE_MIN_MIN = -60,
+            TIMEZONE_MIN_MAX = 60;
+
     /**
      * From Joda API: GregorianChronology.java
      */
@@ -131,28 +126,6 @@
         return true;
     }
 
-    //ATime s
-    /**
-     * Check whether the given time value is a valid time following the gregorian calendar system.
-     * 
-     * @param fields
-     * @return
-     */
-    public boolean validateTime(int hour, int min, int sec, int millis) {
-        // Check whether each field is within the value domain
-        if (hour < FIELD_MINS[3] || hour > FIELD_MAXS[3])
-            return false;
-        if (min < FIELD_MINS[4] || min > FIELD_MAXS[4])
-            return false;
-        if (sec < FIELD_MINS[5] || sec > FIELD_MAXS[5])
-            return false;
-        if (millis < FIELD_MINS[6] || millis > FIELD_MAXS[6])
-            return false;
-     
-        return true;
-    }
-    //ATime e
-    
     /**
      * Check whether the given time zone value is a valid time zone following the gregorian calendar system.
      * 
@@ -191,25 +164,9 @@
     public boolean validate(int year, int month, int day, int hour, int min, int sec, int millis, int timezone) {
         return validate(year, month, day, hour, min, sec, millis) && validateTimeZone(timezone);
     }
-    
-    //ATime s
-    /**
-     * Validate the given ora time and time zone.
-     * 
-     * @param hour
-     * @param min
-     * @param sec
-     * @param millis
-     * @param timezone
-     * @return
-     */
-    public boolean validateTime(int hour, int min, int sec, int millis, int timezone) {
-        return validateTime(hour, min, sec, millis) && validateTimeZone(timezone);
-    }
-    //ATime e
 
     /**
-     * Get the chronon time of the given date time and time zone.
+     * Get the UTC chronon time of the given date time and time zone.
      * 
      * @param year
      * @param month
@@ -236,10 +193,9 @@
 
         return chrononTime;
     }
-    
-    //ATime s
+
     /**
-     * Get the ora of the given time and time zone.
+     * Get the chronon time (number of milliseconds) of the given time and time zone.
      * 
      * @param hour
      * @param min
@@ -248,46 +204,73 @@
      * @param timezone
      * @return
      */
-    public int getOra(int hour, int min, int sec, int millis, int timezone) {
+    public int getChronon(int hour, int min, int sec, int millis, int timezone) {
         // Added milliseconds for all fields but month and day
-        int ora = (hour - timezone / 4) * CHRONON_OF_HOUR
-                + (min - (timezone % 4) * 15) * CHRONON_OF_MINUTE + sec * CHRONON_OF_SECOND + millis;
-
+        int ora = (hour - timezone / 4) * CHRONON_OF_HOUR + (min - (timezone % 4) * 15) * CHRONON_OF_MINUTE + sec
+                * CHRONON_OF_SECOND + millis;
         return ora;
     }
-    //ATime e
-    
+
     /**
-     * Get the ISO8601 compatible representation of the given chronon time, using the extended form as<br/>
-     * [-]YYYY-MM-DDThh:mm:ss.xxx[+|-]hh:mm
+     * Get the extended string representation of the given UTC chronon time under the given time zone. Only fields before
+     * the given field index will be returned.
+     * <p/>
+     * The extended string representation is like:<br/>
+     * [-]YYYY-MM-DDThh:mm:ss.xxx[Z|[+|-]hh:mm]
+     * 
+     * @param chrononTime
+     * @param timezone
+     * @param sbder
+     * @param untilField
      */
-    @Override
-    public void getStringRep(long chrononTime, StringBuilder sbder) {
-        getExtendStringRepWithTimezone(chrononTime, 0, sbder);
-    }
+    public void getExtendStringRepWithTimezoneUntilField(long chrononTime, int timezone, StringBuilder sbder,
+            int startField, int untilField) {
 
-    public void getStringRep(long chrononTime, DataOutput out) throws IOException {
         int year = getYear(chrononTime);
         int month = getMonthOfYear(chrononTime, year);
 
-        out.writeUTF(String.format(year < 0 ? "%05d" : "%04d", year) + "-" + String.format("%02d", month) + "-"
-                + String.format("%02d", getDayOfMonthYear(chrononTime, year, month)) + "T"
-                + String.format("%02d", getHourOfDay(chrononTime)) + ":"
-                + String.format("%02d", getMinOfHour(chrononTime)) + ":"
-                + String.format("%02d", getSecOfMin(chrononTime)) + "."
-                + String.format("%03d", getMillisOfSec(chrononTime)) + "Z");
-    }
-
-    public void getExtendStringRepWithTimezone(long chrononTime, int timezone, StringBuilder sbder) {
-        int year = getYear(chrononTime);
-        int month = getMonthOfYear(chrononTime, year);
-
-        sbder.append(String.format(year < 0 ? "%05d" : "%04d", year)).append("-").append(String.format("%02d", month)).append("-")
-                .append(String.format("%02d", getDayOfMonthYear(chrononTime, year, month))).append("T")
-                .append(String.format("%02d", getHourOfDay(chrononTime))).append(":")
-                .append(String.format("%02d", getMinOfHour(chrononTime))).append(":")
-                .append(String.format("%02d", getSecOfMin(chrononTime))).append(".")
-                .append(String.format("%03d", getMillisOfSec(chrononTime)));
+        switch (startField) {
+            case YEAR:
+                sbder.append(String.format(year < 0 ? "%05d" : "%04d", year));
+                if (untilField == YEAR) {
+                    return;
+                }
+            case MONTH:
+                if (startField != MONTH)
+                    sbder.append("-");
+                sbder.append(String.format("%02d", month));
+                if (untilField == MONTH) {
+                    return;
+                }
+            case DAY:
+                if (startField != DAY)
+                    sbder.append("-");
+                sbder.append(String.format("%02d", getDayOfMonthYear(chrononTime, year, month)));
+                if (untilField == DAY) {
+                    break;
+                }
+            case HOUR:
+                if (startField != HOUR)
+                    sbder.append("T");
+                sbder.append(String.format("%02d", getHourOfDay(chrononTime)));
+                if (untilField == HOUR) {
+                    break;
+                }
+            case MINUTE:
+                if (startField != MINUTE)
+                    sbder.append(":");
+                sbder.append(String.format("%02d", getMinOfHour(chrononTime)));
+                if (untilField == MINUTE) {
+                    break;
+                }
+            case SECOND:
+                if (startField != SECOND)
+                    sbder.append(":");
+                sbder.append(String.format("%02d", getSecOfMin(chrononTime)));
+                // add millisecond as the precision fields of a second
+                sbder.append(".").append(String.format("%03d", getMillisOfSec(chrononTime)));
+                break;
+        }
 
         if (timezone == 0) {
             sbder.append("Z");
@@ -298,17 +281,51 @@
                     .append(String.format("%02d", tzMin));
         }
     }
-    
-    public void getBasicStringRepWithTimezone(long chrononTime, int timezone, StringBuilder sbder) {
+
+    /**
+     * Get the basic string representation of a chronon time with the given time zone.
+     * 
+     * @param chrononTime
+     * @param timezone
+     * @param sbder
+     */
+    public void getBasicStringRepWithTimezoneUntiField(long chrononTime, int timezone, StringBuilder sbder,
+            int startField, int untilField) {
         int year = getYear(chrononTime);
         int month = getMonthOfYear(chrononTime, year);
 
-        sbder.append(String.format(year < 0 ? "%05d" : "%04d", year)).append(String.format("%02d", month))
-                .append(String.format("%02d", getDayOfMonthYear(chrononTime, year, month))).append("T")
-                .append(String.format("%02d", getHourOfDay(chrononTime)))
-                .append(String.format("%02d", getMinOfHour(chrononTime)))
-                .append(String.format("%02d", getSecOfMin(chrononTime)))
-                .append(String.format("%03d", getMillisOfSec(chrononTime)));
+        switch (startField) {
+            case YEAR:
+                sbder.append(String.format(year < 0 ? "%05d" : "%04d", year));
+                if (untilField == YEAR) {
+                    return;
+                }
+            case MONTH:
+                sbder.append(String.format("%02d", month));
+                if (untilField == MONTH) {
+                    return;
+                }
+            case DAY:
+                sbder.append(String.format("%02d", getDayOfMonthYear(chrononTime, year, month)));
+                if (untilField == DAY) {
+                    break;
+                }
+            case HOUR:
+                sbder.append(String.format("%02d", getHourOfDay(chrononTime)));
+                if (untilField == HOUR) {
+                    break;
+                }
+            case MINUTE:
+                sbder.append(String.format("%02d", getMinOfHour(chrononTime)));
+                if (untilField == MINUTE) {
+                    break;
+                }
+            case SECOND:
+                sbder.append(String.format("%02d", getSecOfMin(chrononTime)));
+                // add millisecond as the precision fields of a second
+                sbder.append(String.format("%03d", getMillisOfSec(chrononTime)));
+                break;
+        }
 
         if (timezone == 0) {
             sbder.append("Z");
@@ -319,644 +336,6 @@
                     .append(String.format("%02d", tzMin));
         }
     }
-    
-    //ATime s
-    /**
-     * Get the ISO8601 compatible representation of the given ora time, using the extended form as<br/>
-     * hh:mm:ss.xxx[+|-]hh:mm
-     */
-    public void getStringRepTime(int ora, StringBuilder sbder) {
-    	getExtendStringRepTimeWithTimezone(ora, 0, sbder);
-    }
-
-    public void getStringRepTime(int ora, DataOutput out) throws IOException {
-
-        out.writeUTF(String.format("%02d", getHourOfDay(ora)) + ":"
-                + String.format("%02d", getMinOfHour(ora)) + ":"
-                + String.format("%02d", getSecOfMin(ora)) + "."
-                + String.format("%03d", getMillisOfSec(ora)) + "Z");
-    }
-
-    public void getExtendStringRepTimeWithTimezone(int chrononTime, int timezone, StringBuilder sbder) {
-
-        sbder.append(String.format("%02d", getHourOfDay(chrononTime))).append(":")
-                .append(String.format("%02d", getMinOfHour(chrononTime))).append(":")
-                .append(String.format("%02d", getSecOfMin(chrononTime))).append(".")
-                .append(String.format("%03d", getMillisOfSec(chrononTime)));
-
-        if (timezone == 0) {
-            sbder.append("Z");
-        } else {
-            short tzMin = (short) ((timezone % 4) * 15);
-            short tzHr = (short) (timezone / 4);
-            sbder.append((tzHr >= 0 ? "+" : "-")).append(String.format("%02d", (tzHr < 0 ? -tzHr : tzHr))).append(":")
-                    .append(String.format("%02d", tzMin));
-        }
-    }
-    
-    public void getBasicStringRepTimeWithTimezone(int ora, int timezone, StringBuilder sbder) {
-       
-    	sbder.append(String.format("%02d", getHourOfDay(ora)))
-                .append(String.format("%02d", getMinOfHour(ora)))
-                .append(String.format("%02d", getSecOfMin(ora)))
-                .append(String.format("%03d", getMillisOfSec(ora)));
-
-        if (timezone == 0) {
-            sbder.append("Z");
-        } else {
-            short tzMin = (short) ((timezone % 4) * 15);
-            short tzHr = (short) (timezone / 4);
-            sbder.append((tzHr >= 0 ? "+" : "-")).append(String.format("%02d", (tzHr < 0 ? -tzHr : tzHr)))
-                    .append(String.format("%02d", tzMin));
-        }
-    }
-    //ATime e
-
-    /* (non-Javadoc)
-     * @see edu.uci.ics.asterix.om.base.temporal.ICalendarSystem#parseStringRep(java.lang.String, java.io.DataOutput)
-     */
-    @Override
-    public void parseStringRep(String datetime, DataOutput out) throws HyracksDataException {
-        int offset = 0;
-        int year, month, day, hour, min, sec, millis = 0;
-        int timezone = 0;
-        boolean positive = true;
-        if (datetime.contains(":")) {
-            // parse extended form
-            if (datetime.charAt(offset) == '-') {
-                offset++;
-                positive = false;
-            }
-
-            if (datetime.charAt(offset + 4) != '-' || datetime.charAt(offset + 7) != '-')
-                throw new HyracksDataException(datetime + ERROR_FORMAT);
-
-            year = Short.parseShort(datetime.substring(offset, offset + 4));
-            month = Short.parseShort(datetime.substring(offset + 5, offset + 7));
-            day = Short.parseShort(datetime.substring(offset + 8, offset + 10));
-
-            if (!positive)
-                year *= -1;
-
-            offset += 11;
-
-            if (datetime.charAt(offset + 2) != ':' || datetime.charAt(offset + 5) != ':')
-                throw new HyracksDataException(datetime + ERROR_FORMAT);
-
-            hour = Short.parseShort(datetime.substring(offset, offset + 2));
-            min = Short.parseShort(datetime.substring(offset + 3, offset + 5));
-            sec = Short.parseShort(datetime.substring(offset + 6, offset + 8));
-
-            offset += 8;
-            if (datetime.length() > offset && datetime.charAt(offset) == '.') {
-                millis = Short.parseShort(datetime.substring(offset + 1, offset + 4));
-                offset += 4;
-            }
-
-            if (datetime.length() > offset) {
-                if (datetime.charAt(offset) != 'Z') {
-                    if ((datetime.charAt(offset) != '+' && datetime.charAt(offset) != '-')
-                            || (datetime.charAt(offset + 3) != ':'))
-                        throw new HyracksDataException(datetime + ERROR_FORMAT);
-
-                    short timezoneHour = Short.parseShort(datetime.substring(offset + 1, offset + 3));
-                    short timezoneMinute = Short.parseShort(datetime.substring(offset + 4, offset + 6));
-
-                    if (datetime.charAt(offset) == '-')
-                        timezone = (byte) -((timezoneHour * 4) + timezoneMinute / 15);
-                    else
-                        timezone = (byte) ((timezoneHour * 4) + timezoneMinute / 15);
-                }
-            }
-
-        } else {
-            // parse basic form
-            if (datetime.charAt(offset) == '-') {
-                offset++;
-                positive = false;
-            }
-
-            year = Short.parseShort(datetime.substring(offset, offset + 4));
-            month = Short.parseShort(datetime.substring(offset + 4, offset + 6));
-            day = Short.parseShort(datetime.substring(offset + 6, offset + 8));
-
-            if (!positive)
-                day *= -1;
-
-            offset += 9;
-
-            hour = Short.parseShort(datetime.substring(offset, offset + 2));
-            min = Short.parseShort(datetime.substring(offset + 2, offset + 4));
-            sec = Short.parseShort(datetime.substring(offset + 4, offset + 6));
-
-            offset += 6;
-            if (datetime.length() > offset && datetime.charAt(offset) == '.') {
-                millis = Short.parseShort(datetime.substring(offset + 1, offset + 4));
-                offset += 4;
-            }
-
-            if (datetime.length() > offset) {
-                if (datetime.charAt(offset) != 'Z') {
-                    if ((datetime.charAt(offset) != '+' && datetime.charAt(offset) != '-'))
-                        throw new HyracksDataException(datetime + ERROR_FORMAT);
-
-                    short timezoneHour = Short.parseShort(datetime.substring(offset + 1, offset + 3));
-                    short timezoneMinute = Short.parseShort(datetime.substring(offset + 3, offset + 5));
-
-                    if (datetime.charAt(offset) == '-')
-                        timezone = (byte) -((timezoneHour * 4) + timezoneMinute / 15);
-                    else
-                        timezone = (byte) ((timezoneHour * 4) + timezoneMinute / 15);
-                }
-            }
-        }
-
-        if (!validate(year, month, day, hour, min, sec, millis, timezone)) {
-            throw new HyracksDataException(datetime + ERROR_FORMAT);
-        }
-
-        long chrononTime = getChronon(year, month, day, hour, min, sec, (int) millis, timezone);
-
-        try {
-            out.writeLong(chrononTime);
-            out.writeInt(timezone);
-        } catch (IOException e) {
-            throw new HyracksDataException(e.toString());
-        }
-    }
-    
-    //ATime s
-    public void parseStringRepTime(String time, DataOutput out) throws HyracksDataException {
-        int offset = 0;
-        int hour, min, sec, millis = 0;
-        int timezone = 0;
-        if (time.contains(":")) {
-//            // parse extended form
-
-            if (time.charAt(offset) == '-')
-                throw new HyracksDataException(time + ERROR_FORMAT);
-
-
-            if (time.charAt(offset + 2) != ':' || time.charAt(offset + 5) != ':')
-                throw new HyracksDataException(time + ERROR_FORMAT);
-
-            hour = Short.parseShort(time.substring(offset, offset + 2));
-            min = Short.parseShort(time.substring(offset + 3, offset + 5));
-            sec = Short.parseShort(time.substring(offset + 6, offset + 8));
-
-            offset += 8;
-            if (time.length() > offset && time.charAt(offset) == '.') {
-                millis = Short.parseShort(time.substring(offset + 1, offset + 4));
-                offset += 4;
-            }
-
-            if (time.length() > offset) {
-                if (time.charAt(offset) != 'Z') {
-                    if ((time.charAt(offset) != '+' && time.charAt(offset) != '-')
-                            || (time.charAt(offset + 3) != ':'))
-                        throw new HyracksDataException(time + ERROR_FORMAT);
-
-                    short timezoneHour = Short.parseShort(time.substring(offset + 1, offset + 3));
-                    short timezoneMinute = Short.parseShort(time.substring(offset + 4, offset + 6));
-
-                    if (time.charAt(offset) == '-')
-                        timezone = (byte) -((timezoneHour * 4) + timezoneMinute / 15);
-                    else
-                        timezone = (byte) ((timezoneHour * 4) + timezoneMinute / 15);
-                }
-            }
-
-        } else {
-            // parse basic form
-            if (time.charAt(offset) == '-')
-                throw new HyracksDataException(time + ERROR_FORMAT);
-
-            hour = Short.parseShort(time.substring(offset, offset + 2));
-            min = Short.parseShort(time.substring(offset + 2, offset + 4));
-            sec = Short.parseShort(time.substring(offset + 4, offset + 6));
-
-            offset += 6;
-            //TODO: Remove the "." requirement from the basic of datetime
-            if (time.length() > offset) {
-                millis = Short.parseShort(time.substring(offset, offset + 3));
-                offset += 3;
-            }
-
-            if (time.length() > offset) {
-                if (time.charAt(offset) != 'Z') {
-                    if ((time.charAt(offset) != '+' && time.charAt(offset) != '-'))
-                        throw new HyracksDataException(time + ERROR_FORMAT);
-
-                    short timezoneHour = Short.parseShort(time.substring(offset + 1, offset + 3));
-                    short timezoneMinute = Short.parseShort(time.substring(offset + 3, offset + 5));
-
-                    if (time.charAt(offset) == '-')
-                        timezone = (byte) -((timezoneHour * 4) + timezoneMinute / 15);
-                    else
-                        timezone = (byte) ((timezoneHour * 4) + timezoneMinute / 15);
-                }
-            }
-        }
-
-        if (!validateTime(hour, min, sec, millis, timezone)) {
-            throw new HyracksDataException(time + ERROR_FORMAT);
-        }
-
-        int ora = getOra(hour, min, sec, (int) millis, timezone);
-
-        try {
-            out.writeInt(ora);
-            out.writeInt(timezone);
-        } catch (IOException e) {
-            throw new HyracksDataException(e.toString());
-        }
-    }
-    //ATime e
-
-    public void parseStringForADatetime(String datetime, AMutableDateTime aMutableDatetime) throws HyracksDataException {
-        int offset = 0;
-        int year, month, day, hour, min, sec, millis = 0;
-        int timezone = 0;
-        boolean positive = true;
-        if (datetime.contains(":")) {
-            // parse extended form
-            if (datetime.charAt(offset) == '-') {
-                offset++;
-                positive = false;
-            }
-
-            if (datetime.charAt(offset + 4) != '-' || datetime.charAt(offset + 7) != '-')
-                throw new HyracksDataException(datetime + ERROR_FORMAT);
-
-            year = Short.parseShort(datetime.substring(offset, offset + 4));
-            month = Short.parseShort(datetime.substring(offset + 5, offset + 7));
-            day = Short.parseShort(datetime.substring(offset + 8, offset + 10));
-
-            if (!positive)
-                year *= -1;
-
-            offset += 11;
-
-            if (datetime.charAt(offset + 2) != ':' || datetime.charAt(offset + 5) != ':')
-                throw new HyracksDataException(datetime + ERROR_FORMAT);
-
-            hour = Short.parseShort(datetime.substring(offset, offset + 2));
-            min = Short.parseShort(datetime.substring(offset + 3, offset + 5));
-            sec = Short.parseShort(datetime.substring(offset + 6, offset + 8));
-
-            offset += 8;
-            if (datetime.length() > offset && datetime.charAt(offset) == '.') {
-                millis = Short.parseShort(datetime.substring(offset + 1, offset + 4));
-                offset += 4;
-            }
-
-            if (datetime.length() > offset) {
-                if (datetime.charAt(offset) != 'Z') {
-                    if ((datetime.charAt(offset) != '+' && datetime.charAt(offset) != '-')
-                            || (datetime.charAt(offset + 3) != ':'))
-                        throw new HyracksDataException(datetime + ERROR_FORMAT);
-
-                    short timezoneHour = Short.parseShort(datetime.substring(offset + 1, offset + 3));
-                    short timezoneMinute = Short.parseShort(datetime.substring(offset + 4, offset + 6));
-
-                    if (datetime.charAt(offset) == '-')
-                        timezone = (byte) -((timezoneHour * 4) + timezoneMinute / 15);
-                    else
-                        timezone = (byte) ((timezoneHour * 4) + timezoneMinute / 15);
-                }
-            }
-
-        } else {
-            // parse basic form
-            if (datetime.charAt(offset) == '-') {
-                offset++;
-                positive = false;
-            }
-
-            year = Short.parseShort(datetime.substring(offset, offset + 4));
-            month = Short.parseShort(datetime.substring(offset + 4, offset + 6));
-            day = Short.parseShort(datetime.substring(offset + 6, offset + 8));
-
-            if (!positive)
-                day *= -1;
-
-            offset += 9;
-
-            hour = Short.parseShort(datetime.substring(offset, offset + 2));
-            min = Short.parseShort(datetime.substring(offset + 2, offset + 4));
-            sec = Short.parseShort(datetime.substring(offset + 4, offset + 6));
-
-            offset += 6;
-            if (datetime.length() > offset && datetime.charAt(offset) == '.') {
-                millis = Short.parseShort(datetime.substring(offset + 1, offset + 4));
-                offset += 4;
-            }
-
-            if (datetime.length() > offset) {
-                if (datetime.charAt(offset) != 'Z') {
-                    if ((datetime.charAt(offset) != '+' && datetime.charAt(offset) != '-'))
-                        throw new HyracksDataException(datetime + ERROR_FORMAT);
-
-                    short timezoneHour = Short.parseShort(datetime.substring(offset + 1, offset + 3));
-                    short timezoneMinute = Short.parseShort(datetime.substring(offset + 3, offset + 5));
-
-                    if (datetime.charAt(offset) == '-')
-                        timezone = (byte) -((timezoneHour * 4) + timezoneMinute / 15);
-                    else
-                        timezone = (byte) ((timezoneHour * 4) + timezoneMinute / 15);
-                }
-            }
-        }
-
-        if (!validate(year, month, day, hour, min, sec, millis, timezone)) {
-            throw new HyracksDataException(datetime + ERROR_FORMAT);
-        }
-
-        aMutableDatetime.setValue(getChronon(year, month, day, hour, min, sec, (int) millis, timezone));
-    }
-
-    //ATime s
-    public void parseStringForATime(String time, AMutableTime aMutableTime) throws HyracksDataException {
-        int offset = 0;
-        int hour, min, sec, millis = 0;
-        int timezone = 0;
-        if (time.contains(":")) {
-            // parse extended form
-            if (time.charAt(offset) == '-') {
-            	throw new HyracksDataException(time + ERROR_FORMAT);
-            	}
-
-            if (time.charAt(offset + 2) != ':' || time.charAt(offset + 5) != ':')
-                throw new HyracksDataException(time + ERROR_FORMAT);
-
-            hour = Short.parseShort(time.substring(offset, offset + 2));
-            min = Short.parseShort(time.substring(offset + 3, offset + 5));
-            sec = Short.parseShort(time.substring(offset + 6, offset + 8));
-
-            offset += 8;
-            if (time.length() > offset && time.charAt(offset) == '.') {
-                millis = Short.parseShort(time.substring(offset + 1, offset + 4));
-                offset += 4;
-            }
-
-            if (time.length() > offset) {
-                if (time.charAt(offset) != 'Z') {
-                    if ((time.charAt(offset) != '+' && time.charAt(offset) != '-')
-                            || (time.charAt(offset + 3) != ':'))
-                        throw new HyracksDataException(time + ERROR_FORMAT);
-
-                    short timezoneHour = Short.parseShort(time.substring(offset + 1, offset + 3));
-                    short timezoneMinute = Short.parseShort(time.substring(offset + 4, offset + 6));
-
-                    if (time.charAt(offset) == '-')
-                        timezone = (byte) -((timezoneHour * 4) + timezoneMinute / 15);
-                    else
-                        timezone = (byte) ((timezoneHour * 4) + timezoneMinute / 15);
-                }
-            }
-
-        } else {
-            // parse basic form
-            if (time.charAt(offset) == '-') {
-            	throw new HyracksDataException(time + ERROR_FORMAT);
-            }
-
-            hour = Short.parseShort(time.substring(offset, offset + 2));
-            min = Short.parseShort(time.substring(offset + 2, offset + 4));
-            sec = Short.parseShort(time.substring(offset + 4, offset + 6));
-
-            offset += 6;
-            //TODO: Remove the "."
-            if (time.length() > offset) {
-                millis = Short.parseShort(time.substring(offset, offset + 3));
-                offset += 3;
-            }
-
-            if (time.length() > offset) {
-                if (time.charAt(offset) != 'Z') {
-                    if ((time.charAt(offset) != '+' && time.charAt(offset) != '-'))
-                        throw new HyracksDataException(time + ERROR_FORMAT);
-
-                    short timezoneHour = Short.parseShort(time.substring(offset + 1, offset + 3));
-                    short timezoneMinute = Short.parseShort(time.substring(offset + 3, offset + 5));
-
-                    if (time.charAt(offset) == '-')
-                        timezone = (byte) -((timezoneHour * 4) + timezoneMinute / 15);
-                    else
-                        timezone = (byte) ((timezoneHour * 4) + timezoneMinute / 15);
-                }
-            }
-        }
-
-        if (!validateTime(hour, min, sec, millis, timezone)) {
-            throw new HyracksDataException(time + ERROR_FORMAT);
-        }
-
-        aMutableTime.setValue(getOra(hour, min, sec, millis, timezone));
-    }
-    //ATime e
-
-    public void parseStringForADatetime(byte[] datetime, int offset, AMutableDateTime aMutableDatetime)
-            throws AlgebricksException {
-        int year, month, day, hour, min, sec, millis = 0;
-        int timezone = 0;
-        boolean positive = true;
-        boolean isExtendedForm = false;
-        if (datetime[offset + 13] == ':' || datetime[offset + 14] == ':') {
-            isExtendedForm = true;
-        }
-        if (isExtendedForm) {
-            // parse extended form
-            if (datetime[offset] == '-') {
-                offset++;
-                positive = false;
-            }
-
-            if (datetime[offset + 4] != '-' || datetime[offset + 7] != '-')
-                throw new AlgebricksException(datetime + ERROR_FORMAT);
-
-            year = getValue(datetime, offset, 4);
-            month = getValue(datetime, offset + 5, 2);
-            day = getValue(datetime, offset + 8, 2);
-
-            if (!positive)
-                year *= -1;
-
-            offset += 11;
-
-            if (datetime[offset + 2] != ':' || datetime[offset + 5] != ':')
-                throw new AlgebricksException(datetime + ERROR_FORMAT);
-
-            hour = getValue(datetime, offset, 2);
-            min = getValue(datetime, offset + 3, 2);
-            sec = getValue(datetime, offset + 6, 2);
-
-            offset += 8;
-            if (datetime.length > offset && datetime[offset] == '.') {
-                millis = getValue(datetime, offset + 1, 3);
-                offset += 4;
-            }
-
-            if (datetime.length > offset) {
-                if (datetime[offset] != 'Z') {
-                    if ((datetime[offset] != '+' && datetime[offset] != '-') || (datetime[offset + 3] != ':'))
-                        throw new AlgebricksException(datetime + ERROR_FORMAT);
-
-                    short timezoneHour = getValue(datetime, offset + 1, 2);
-                    short timezoneMinute = getValue(datetime, offset + 4, 2);
-
-                    if (datetime[offset] == '-')
-                        timezone = (byte) -((timezoneHour * 4) + timezoneMinute / 15);
-                    else
-                        timezone = (byte) ((timezoneHour * 4) + timezoneMinute / 15);
-                }
-            }
-
-        } else {
-            // parse basic form
-            if (datetime[offset] == '-') {
-                offset++;
-                positive = false;
-            }
-
-            year = getValue(datetime, offset, 4);
-            month = getValue(datetime, offset + 4, 2);
-            day = getValue(datetime, offset + 6, 2);
-
-            if (!positive)
-                day *= -1;
-
-            offset += 9;
-
-            hour = getValue(datetime, offset, 2);
-            min = getValue(datetime, offset + 2, 2);
-            sec = getValue(datetime, offset + 4, 2);
-
-            offset += 6;
-            if (datetime.length > offset && datetime[offset] == '.') {
-                millis = getValue(datetime, offset + 1, 3);
-                offset += 4;
-            }
-
-            if (datetime.length > offset) {
-                if (datetime[offset] != 'Z') {
-                    if ((datetime[offset] != '+' && datetime[offset] != '-'))
-                        throw new AlgebricksException(datetime + ERROR_FORMAT);
-
-                    short timezoneHour = getValue(datetime, offset + 1, 2);
-                    short timezoneMinute = getValue(datetime, offset + 3, 2);
-
-                    if (datetime[offset] == '-')
-                        timezone = (byte) -((timezoneHour * 4) + timezoneMinute / 15);
-                    else
-                        timezone = (byte) ((timezoneHour * 4) + timezoneMinute / 15);
-                }
-            }
-        }
-
-        if (!validate(year, month, day, hour, min, sec, millis, timezone)) {
-            throw new AlgebricksException(datetime + ERROR_FORMAT);
-        }
-
-        aMutableDatetime.setValue(getChronon(year, month, day, hour, min, sec, (int) millis, timezone));
-    }
-
-    //ATime s
-    public void parseStringForATime(byte[] time, int offset, int length, AMutableTime aMutableTime)
-            throws AlgebricksException {
-        int hour, min, sec, millis = 0;
-        int timezone = 0;
-        boolean isExtendedForm = false;
-        if (time[offset + 2] == ':') {
-            isExtendedForm = true;
-        }
-        if (isExtendedForm) {
-            // parse extended form
-            if (time[offset] == '-') 
-            	throw new AlgebricksException(time + ERROR_FORMAT);
-            	
-
-            if (time[offset + 5] != ':')
-                throw new AlgebricksException(time + ERROR_FORMAT);
-
-            hour = getValue(time, offset, 2);
-            min = getValue(time, offset + 3, 2);
-            sec = getValue(time, offset + 6, 2);
-
-            //if (hour==24) hour=0;
-            
-            offset += 8;
-            if (length > offset && time[offset] == '.') {
-                millis = getValue(time, offset + 1, 3);
-                offset += 4;
-            }
-
-            if (length > offset) {
-                if (time[offset] != 'Z') {
-                    if ((time[offset] != '+' && time[offset] != '-') || (time[offset + 3] != ':'))
-                        throw new AlgebricksException(time + ERROR_FORMAT);
-
-                    short timezoneHour = getValue(time, offset + 1, 2);
-                    short timezoneMinute = getValue(time, offset + 4, 2);
-
-                    if (time[offset] == '-')
-                        timezone = (byte) -((timezoneHour * 4) + timezoneMinute / 15);
-                    else
-                        timezone = (byte) ((timezoneHour * 4) + timezoneMinute / 15);
-                }
-            }
-
-        } else {
-            // parse basic form
-        	if (time[offset] == '-') 
-            	throw new AlgebricksException(time + ERROR_FORMAT);
-
-            hour = getValue(time, offset, 2);
-            min = getValue(time, offset + 2, 2);
-            sec = getValue(time, offset + 4, 2);
-
-            offset += 6;
-            //TODO: Remove "."
-            if (length > offset) {
-                millis = getValue(time, offset, 3);
-                offset += 3;
-            }
-
-            if (length > offset) {
-                if (time[offset] != 'Z') {
-                    if ((time[offset] != '+' && time[offset] != '-'))
-                        throw new AlgebricksException(time + ERROR_FORMAT);
-
-                    short timezoneHour = getValue(time, offset + 1, 2);
-                    short timezoneMinute = getValue(time, offset + 3, 2);
-
-                    if (time[offset] == '-')
-                        timezone = (byte) -((timezoneHour * 4) + timezoneMinute / 15);
-                    else
-                        timezone = (byte) ((timezoneHour * 4) + timezoneMinute / 15);
-                }
-            }
-        }
-
-        if (!validateTime(hour, min, sec, millis, timezone)) {
-            throw new AlgebricksException(time + ERROR_FORMAT);
-        }
-
-        aMutableTime.setValue(getOra(hour, min, sec, millis, timezone));
-    }
-    //ATime e
-    
-    private short getValue(byte[] b, int offset, int numberOfDigits) throws AlgebricksException {
-        short value = 0;
-        for (int i = 0; i < numberOfDigits; i++) {
-            if ((b[offset] >= '0' && b[offset] <= '9'))
-                value = (short) (value * 10 + b[offset++] - '0');
-            else
-                throw new AlgebricksException(ERROR_FORMAT);
-
-        }
-        return value;
-    }
 
     /**
      * Check whether a given year is a leap year.
@@ -1095,6 +474,12 @@
         return (int) ((millis - dateMillis) / CHRONON_OF_DAY) + 1;
     }
 
+    /**
+     * Get the hour of the day for the given chronon time.
+     * 
+     * @param millis
+     * @return
+     */
     public int getHourOfDay(long millis) {
         int hour = (int) ((millis % CHRONON_OF_DAY) / CHRONON_OF_HOUR);
 
@@ -1107,10 +492,16 @@
                 hour += 23;
             }
         }
-        
+
         return hour;
     }
 
+    /**
+     * Get the minute of the hour for the given chronon time.
+     * 
+     * @param millis
+     * @return
+     */
     public int getMinOfHour(long millis) {
         int min = (int) ((millis % CHRONON_OF_HOUR) / CHRONON_OF_MINUTE);
         if (millis < 0) {
@@ -1125,6 +516,12 @@
         return min;
     }
 
+    /**
+     * Get the second of the minute for the given chronon time.
+     * 
+     * @param millis
+     * @return
+     */
     public int getSecOfMin(long millis) {
         int sec = (int) ((millis % CHRONON_OF_MINUTE) / CHRONON_OF_SECOND);
         if (millis < 0) {
@@ -1139,6 +536,12 @@
         return sec;
     }
 
+    /**
+     * Get the millisecond of the second for the given chronon time.
+     * 
+     * @param millis
+     * @return
+     */
     public int getMillisOfSec(long millis) {
         int ms = (int) (millis % CHRONON_OF_SECOND);
         if (millis < 0 && ms < 0) {
diff --git a/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/temporal/ICalendarSystem.java b/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/temporal/ICalendarSystem.java
index 9f0d68b..410b73a 100644
--- a/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/temporal/ICalendarSystem.java
+++ b/asterix-om/src/main/java/edu/uci/ics/asterix/om/base/temporal/ICalendarSystem.java
@@ -7,19 +7,9 @@
 public interface ICalendarSystem {
 
     public boolean validate(int year, int month, int day, int hour, int min, int sec, int millis, int timezone);
-    
-    public boolean validateTime(int hour, int min, int sec, int millis, int timezone);
-    
+
     public long getChronon(int year, int month, int day, int hour, int min, int sec, int millis, int timezone);
-    
-    public int getOra(int hour, int min, int sec, int millis, int timezone);
 
-    public void getStringRep(long chrononTime, StringBuilder sbder);
-    
-    public void getStringRepTime(int ora, StringBuilder sbder);
-
-    public void parseStringRep(String stringRep, DataOutput out) throws HyracksDataException;
-    
-    public void parseStringRepTime(String stringRep, DataOutput out) throws HyracksDataException;
+    public int getChronon(int hour, int min, int sec, int millis, int timezone);
 
 }
diff --git a/asterix-om/src/main/java/edu/uci/ics/asterix/om/util/NonTaggedFormatUtil.java b/asterix-om/src/main/java/edu/uci/ics/asterix/om/util/NonTaggedFormatUtil.java
index e1eaa7c..712843a 100644
--- a/asterix-om/src/main/java/edu/uci/ics/asterix/om/util/NonTaggedFormatUtil.java
+++ b/asterix-om/src/main/java/edu/uci/ics/asterix/om/util/NonTaggedFormatUtil.java
@@ -90,8 +90,9 @@
             case INT64:
             case DOUBLE:
             case DATETIME:
-            case DURATION:
                 return 8;
+            case DURATION:
+                return 12;
             case POINT:
                 return 16;
             case POINT3D:
diff --git a/asterix-runtime/src/main/java/edu/uci/ics/asterix/runtime/evaluators/constructors/ADateConstructorDescriptor.java b/asterix-runtime/src/main/java/edu/uci/ics/asterix/runtime/evaluators/constructors/ADateConstructorDescriptor.java
index f3b4ed1..93b8f11 100644
--- a/asterix-runtime/src/main/java/edu/uci/ics/asterix/runtime/evaluators/constructors/ADateConstructorDescriptor.java
+++ b/asterix-runtime/src/main/java/edu/uci/ics/asterix/runtime/evaluators/constructors/ADateConstructorDescriptor.java
@@ -8,6 +8,7 @@
 import edu.uci.ics.asterix.om.base.ADate;
 import edu.uci.ics.asterix.om.base.AMutableDate;
 import edu.uci.ics.asterix.om.base.ANull;
+import edu.uci.ics.asterix.om.base.temporal.GregorianCalendarSystem;
 import edu.uci.ics.asterix.om.types.ATypeTag;
 import edu.uci.ics.asterix.om.types.BuiltinType;
 import edu.uci.ics.asterix.runtime.evaluators.base.AbstractScalarFunctionDynamicDescriptor;
@@ -41,11 +42,8 @@
                     private ArrayBackedValueStorage outInput = new ArrayBackedValueStorage();
                     private IEvaluator eval = args[0].createEvaluator(outInput);
                     private int offset;
-                    private short year, month, day, hour, minute, value;
-                    private byte timezonePart = 0;
-                    private boolean positive = true;
                     private String errorMessage = "This can not be an instance of date";
-                    private AMutableDate aDate = new AMutableDate(0, 0, 0, 0);
+                    private AMutableDate aDate = new AMutableDate(0);
                     @SuppressWarnings("unchecked")
                     private ISerializerDeserializer<ADate> dateSerde = AqlSerializerDeserializerProvider.INSTANCE
                             .getSerializerDeserializer(BuiltinType.ADATE);
@@ -53,6 +51,8 @@
                     private ISerializerDeserializer<ANull> nullSerde = AqlSerializerDeserializerProvider.INSTANCE
                             .getSerializerDeserializer(BuiltinType.ANULL);
 
+                    private GregorianCalendarSystem gCalInstance = GregorianCalendarSystem.getInstance();
+
                     @Override
                     public void evaluate(IFrameTupleReference tuple) throws AlgebricksException {
 
@@ -61,73 +61,229 @@
                             eval.evaluate(tuple);
                             byte[] serString = outInput.getBytes();
                             if (serString[0] == SER_STRING_TYPE_TAG) {
+
+                                int length = ((serString[1] & 0xff) << 8) + ((serString[2] & 0xff) << 0) + 3;
+
                                 offset = 3;
 
-                                if (serString[offset] == '-') {
-                                    offset++;
-                                    positive = false;
-                                }
-
-                                if (serString[offset + 4] != '-' || serString[offset + 7] != '-')
-                                    throw new AlgebricksException(errorMessage);
-
-                                year = getValue(serString, offset, 4);
-                                month = getValue(serString, offset + 5, 2);
-                                day = getValue(serString, offset + 8, 2);
-
-                                if (year < 0 || year > 9999 || month < 0 || month > 12 || day < 0 || day > 31)
-                                    throw new AlgebricksException(errorMessage);
-
-                                offset += 10;
-
-                                if (outInput.getLength() > offset) {
-                                    if (serString[offset] == 'Z')
-                                        timezonePart = 0;
-                                    else {
-                                        if ((serString[offset] != '+' && serString[offset] != '-')
-                                                || (serString[offset + 3] != ':'))
-                                            throw new AlgebricksException(errorMessage);
-
-                                        hour = getValue(serString, offset + 1, 2);
-                                        minute = getValue(serString, offset + 4, 2);
-
-                                        if (hour < 0 || hour > 24 || (hour == 24 && minute != 0)
-                                                || (minute != 0 && minute != 15 && minute != 30 && minute != 45))
-                                            throw new AlgebricksException(errorMessage);
-
-                                        if (serString[offset] == '-')
-                                            timezonePart = (byte) -((hour * 4) + minute / 15);
-                                        else
-                                            timezonePart = (byte) ((hour * 4) + minute / 15);
+                                int year = 0, month = 0, day = 0;
+                                int timezone = 0;
+                                boolean positive = true;
+                                if (serString[offset + 4] == '-' || serString[offset + 5] == '-') {
+                                    // parse extended form
+                                    if (serString[offset] == '-') {
+                                        offset++;
+                                        positive = false;
                                     }
 
+                                    if (serString[offset + 4] != '-' || serString[offset + 7] != '-')
+                                        throw new AlgebricksException(errorMessage);
+
+                                    // year
+                                    for (int i = 0; i < 4; i++) {
+                                        if ((serString[offset + i] >= '0' && serString[offset + i] <= '9')) {
+                                            year = year * 10 + serString[offset + i] - '0';
+                                        } else {
+                                            throw new AlgebricksException(errorMessage);
+                                        }
+                                    }
+
+                                    if (year < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.YEAR]
+                                            || year > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.YEAR]) {
+                                        throw new AlgebricksException(errorMessage + ": year " + year);
+                                    }
+
+                                    offset += 5;
+
+                                    // month
+                                    for (int i = 0; i < 2; i++) {
+                                        if ((serString[offset + i] >= '0' && serString[offset + i] <= '9')) {
+                                            month = month * 10 + serString[offset + i] - '0';
+                                        } else {
+                                            throw new AlgebricksException(errorMessage);
+                                        }
+                                    }
+
+                                    if (month < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.MONTH]
+                                            || month > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.MONTH]) {
+                                        throw new AlgebricksException(errorMessage + ": month " + month);
+                                    }
+
+                                    offset += 3;
+
+                                    // day
+                                    for (int i = 0; i < 2; i++) {
+                                        if ((serString[offset + i] >= '0' && serString[offset + i] <= '9')) {
+                                            day = day * 10 + serString[offset + i] - '0';
+                                        } else {
+                                            throw new AlgebricksException(errorMessage);
+                                        }
+                                    }
+
+                                    if (day < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.DAY]
+                                            || day > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.DAY]) {
+                                        throw new AlgebricksException(errorMessage + ": day " + day);
+                                    }
+
+                                    offset += 2;
+
+                                    if (!positive)
+                                        year *= -1;
+
+                                    if (length > offset) {
+                                        if (serString[offset] != 'Z') {
+                                            if ((serString[offset] != '+' && serString[offset] != '-')
+                                                    || (serString[offset + 3] != ':'))
+                                                throw new AlgebricksException(errorMessage);
+
+                                            short timezoneHour = 0;
+                                            short timezoneMinute = 0;
+
+                                            for (int i = 0; i < 2; i++) {
+                                                if ((serString[offset + 1 + i] >= '0' && serString[offset + 1 + i] <= '9'))
+                                                    timezoneHour = (short) (timezoneHour * 10
+                                                            + serString[offset + 1 + i] - '0');
+                                                else
+                                                    throw new AlgebricksException(errorMessage);
+
+                                            }
+
+                                            for (int i = 0; i < 2; i++) {
+                                                if ((serString[offset + 4 + i] >= '0' && serString[offset + 4 + i] <= '9'))
+                                                    timezoneMinute = (short) (timezoneMinute * 10
+                                                            + serString[offset + 4 + i] - '0');
+                                                else
+                                                    throw new AlgebricksException(errorMessage);
+
+                                                if (serString[offset] == '-')
+                                                    timezone = (byte) -((timezoneHour * 4) + timezoneMinute / 15);
+                                                else
+                                                    timezone = (byte) ((timezoneHour * 4) + timezoneMinute / 15);
+                                            }
+                                        }
+                                    }
+
+                                } else {
+                                    // parse basic form
+                                    if (serString[offset] == '-') {
+                                        offset++;
+                                        positive = false;
+                                    }
+
+                                    // year
+                                    for (int i = 0; i < 4; i++) {
+                                        if ((serString[offset + i] >= '0' && serString[offset + i] <= '9')) {
+                                            year = year * 10 + serString[offset + i] - '0';
+                                        } else {
+                                            throw new AlgebricksException(errorMessage);
+                                        }
+                                    }
+
+                                    if (year < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.YEAR]
+                                            || year > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.YEAR]) {
+                                        throw new AlgebricksException(errorMessage + ": year " + year);
+                                    }
+
+                                    offset += 4;
+
+                                    // month
+                                    for (int i = 0; i < 2; i++) {
+                                        if ((serString[offset + i] >= '0' && serString[offset + i] <= '9')) {
+                                            month = month * 10 + serString[offset + i] - '0';
+                                        } else {
+                                            throw new AlgebricksException(errorMessage);
+                                        }
+                                    }
+
+                                    if (month < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.MONTH]
+                                            || month > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.MONTH]) {
+                                        throw new AlgebricksException(errorMessage + ": month " + month);
+                                    }
+
+                                    offset += 2;
+
+                                    // day
+                                    for (int i = 0; i < 2; i++) {
+                                        if ((serString[offset + i] >= '0' && serString[offset + i] <= '9')) {
+                                            day = day * 10 + serString[offset + i] - '0';
+                                        } else {
+                                            throw new AlgebricksException(errorMessage);
+                                        }
+                                    }
+
+                                    if (day < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.DAY]
+                                            || day > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.DAY]) {
+                                        throw new AlgebricksException(errorMessage + ": day " + day);
+                                    }
+
+                                    offset += 2;
+
+                                    if (!positive)
+                                        year *= -1;
+
+                                    if (length > offset) {
+                                        if (serString[offset] != 'Z') {
+                                            if ((serString[offset] != '+' && serString[offset] != '-'))
+                                                throw new AlgebricksException(errorMessage);
+
+                                            short timezoneHour = 0;
+                                            short timezoneMinute = 0;
+
+                                            for (int i = 0; i < 2; i++) {
+                                                if (serString[offset + 1 + i] >= '0'
+                                                        && serString[offset + 1 + i] <= '9')
+                                                    timezoneHour = (short) (timezoneHour * 10
+                                                            + serString[offset + 1 + i] - '0');
+                                                else
+                                                    throw new AlgebricksException(errorMessage);
+
+                                            }
+
+                                            if (timezoneHour < GregorianCalendarSystem.TIMEZONE_HOUR_MIN
+                                                    || timezoneHour > GregorianCalendarSystem.TIMEZONE_HOUR_MAX) {
+                                                throw new AlgebricksException(errorMessage + ": time zone hour "
+                                                        + timezoneHour);
+                                            }
+
+                                            for (int i = 0; i < 2; i++) {
+                                                if (serString[offset + 3 + i] >= '0'
+                                                        && serString[offset + 3 + i] <= '9')
+                                                    timezoneMinute = (short) (timezoneMinute * 10
+                                                            + serString[offset + 3 + i] - '0');
+                                                else
+                                                    throw new AlgebricksException(errorMessage);
+                                            }
+
+                                            if (timezoneMinute < GregorianCalendarSystem.TIMEZONE_MIN_MIN
+                                                    || timezoneMinute > GregorianCalendarSystem.TIMEZONE_MIN_MAX) {
+                                                throw new AlgebricksException(errorMessage + ": time zone minute "
+                                                        + timezoneMinute);
+                                            }
+
+                                            if (serString[offset] == '-')
+                                                timezone = (byte) -((timezoneHour * 4) + timezoneMinute / 15);
+                                            else
+                                                timezone = (byte) ((timezoneHour * 4) + timezoneMinute / 15);
+                                        }
+                                    }
                                 }
 
-                                if (!positive)
-                                    year *= -1;
+                                long chrononTimeInMs = gCalInstance.getChronon(year, month, day, 0, 0, 0, 0, timezone);
+                                aDate.setValue((int) (chrononTimeInMs / GregorianCalendarSystem.CHRONON_OF_DAY));
+                                if (chrononTimeInMs < 0
+                                        && chrononTimeInMs % GregorianCalendarSystem.CHRONON_OF_DAY != 0)
+                                    aDate.setValue((int) (chrononTimeInMs / GregorianCalendarSystem.CHRONON_OF_DAY) - 1);
 
-                                aDate.setValue(year, month, day, timezonePart);
                                 dateSerde.serialize(aDate, out);
                             } else if (serString[0] == SER_NULL_TYPE_TAG)
                                 nullSerde.serialize(ANull.NULL, out);
                             else
                                 throw new AlgebricksException(errorMessage);
+
                         } catch (IOException e1) {
                             throw new AlgebricksException(errorMessage);
                         }
                     }
-
-                    private short getValue(byte[] b, int offset, int numberOfDigits) throws AlgebricksException {
-                        value = 0;
-                        for (int i = 0; i < numberOfDigits; i++) {
-                            if ((b[offset] >= '0' && b[offset] <= '9'))
-                                value = (short) (value * 10 + b[offset++] - '0');
-                            else
-                                throw new AlgebricksException(errorMessage);
-
-                        }
-                        return value;
-                    }
                 };
             }
         };
diff --git a/asterix-runtime/src/main/java/edu/uci/ics/asterix/runtime/evaluators/constructors/ADateTimeConstructorDescriptor.java b/asterix-runtime/src/main/java/edu/uci/ics/asterix/runtime/evaluators/constructors/ADateTimeConstructorDescriptor.java
index f3fcc73..1fa537b 100644
--- a/asterix-runtime/src/main/java/edu/uci/ics/asterix/runtime/evaluators/constructors/ADateTimeConstructorDescriptor.java
+++ b/asterix-runtime/src/main/java/edu/uci/ics/asterix/runtime/evaluators/constructors/ADateTimeConstructorDescriptor.java
@@ -52,6 +52,8 @@
                     private ISerializerDeserializer<ANull> nullSerde = AqlSerializerDeserializerProvider.INSTANCE
                             .getSerializerDeserializer(BuiltinType.ANULL);
 
+                    private GregorianCalendarSystem gCalInstance = GregorianCalendarSystem.getInstance();
+
                     @Override
                     public void evaluate(IFrameTupleReference tuple) throws AlgebricksException {
 
@@ -60,10 +62,379 @@
                             eval.evaluate(tuple);
                             byte[] serString = outInput.getBytes();
                             if (serString[0] == SER_STRING_TYPE_TAG) {
-
+                                int length = ((serString[1] & 0xff) << 8) + ((serString[2] & 0xff) << 0) + 3;
                                 offset = 3;
-                                GregorianCalendarSystem.getInstance().parseStringForADatetime(serString, offset,
-                                        aDateTime);
+
+                                int year = 0, month = 0, day = 0, hour = 0, min = 0, sec = 0, millis = 0;
+                                int timezone = 0;
+
+                                boolean positive = true;
+                                boolean isExtendedForm = false;
+                                if (serString[offset + 13] == ':' || serString[offset + 14] == ':') {
+                                    isExtendedForm = true;
+                                }
+                                if (isExtendedForm) {
+                                    // parse extended form
+                                    if (serString[offset] == '-') {
+                                        offset++;
+                                        positive = false;
+                                    }
+
+                                    if (serString[offset + 4] != '-' || serString[offset + 7] != '-')
+                                        throw new AlgebricksException(errorMessage);
+
+                                    // year
+                                    for (int i = 0; i < 4; i++) {
+                                        if ((serString[offset + i] >= '0' && serString[offset + i] <= '9')) {
+                                            year = year * 10 + serString[offset + i] - '0';
+                                        } else {
+                                            throw new AlgebricksException(errorMessage);
+                                        }
+                                    }
+
+                                    if (year < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.YEAR]
+                                            || year > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.YEAR]) {
+                                        throw new AlgebricksException(errorMessage + ": year " + year);
+                                    }
+
+                                    offset += 5;
+
+                                    // month
+                                    for (int i = 0; i < 2; i++) {
+                                        if ((serString[offset + i] >= '0' && serString[offset + i] <= '9')) {
+                                            month = month * 10 + serString[offset + i] - '0';
+                                        } else {
+                                            throw new AlgebricksException(errorMessage);
+                                        }
+                                    }
+
+                                    if (month < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.MONTH]
+                                            || month > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.MONTH]) {
+                                        throw new AlgebricksException(errorMessage + ": month " + month);
+                                    }
+
+                                    offset += 3;
+
+                                    // day
+                                    for (int i = 0; i < 2; i++) {
+                                        if ((serString[offset + i] >= '0' && serString[offset + i] <= '9')) {
+                                            day = day * 10 + serString[offset + i] - '0';
+                                        } else {
+                                            throw new AlgebricksException(errorMessage);
+                                        }
+                                    }
+
+                                    if (day < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.DAY]
+                                            || day > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.DAY]) {
+                                        throw new AlgebricksException(errorMessage + ": day " + day);
+                                    }
+
+                                    offset += 2;
+
+                                    if (!positive)
+                                        year *= -1;
+
+                                    // skip the "T" separator
+                                    offset += 1;
+
+                                    if (serString[offset + 2] != ':' || serString[offset + 5] != ':')
+                                        throw new AlgebricksException(errorMessage);
+
+                                    // hour
+                                    for (int i = 0; i < 2; i++) {
+                                        if ((serString[offset + i] >= '0' && serString[offset + i] <= '9')) {
+                                            hour = hour * 10 + serString[offset + i] - '0';
+                                        } else {
+                                            throw new AlgebricksException(errorMessage);
+                                        }
+                                    }
+
+                                    if (hour < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.HOUR]
+                                            || hour > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.HOUR]) {
+                                        throw new AlgebricksException(errorMessage + ": hour " + hour);
+                                    }
+
+                                    offset += 3;
+
+                                    // minute
+                                    for (int i = 0; i < 2; i++) {
+                                        if ((serString[offset + i] >= '0' && serString[offset + i] <= '9')) {
+                                            min = min * 10 + serString[offset + i] - '0';
+                                        } else {
+                                            throw new AlgebricksException(errorMessage);
+                                        }
+                                    }
+
+                                    if (min < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.MINUTE]
+                                            || min > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.MINUTE]) {
+                                        throw new AlgebricksException(errorMessage + ": min " + min);
+                                    }
+
+                                    offset += 3;
+
+                                    // second
+                                    for (int i = 0; i < 2; i++) {
+                                        if ((serString[offset + i] >= '0' && serString[offset + i] <= '9')) {
+                                            sec = sec * 10 + serString[offset + i] - '0';
+                                        } else {
+                                            throw new AlgebricksException(errorMessage);
+                                        }
+                                    }
+
+                                    if (sec < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.SECOND]
+                                            || sec > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.SECOND]) {
+                                        throw new AlgebricksException(errorMessage + ": sec " + sec);
+                                    }
+
+                                    offset += 2;
+
+                                    if (length > offset && serString[offset] == '.') {
+
+                                        offset++;
+                                        int i = 0;
+                                        for (; i < 3 && offset + i < length; i++) {
+                                            if (serString[offset + i] >= '0' && serString[offset + i] <= '9') {
+                                                millis = millis * 10 + serString[offset + i] - '0';
+                                            } else {
+                                                break;
+                                            }
+                                        }
+
+                                        offset += i;
+
+                                        for (; i < 3; i++) {
+                                            millis = millis * 10;
+                                        }
+
+                                        for (; offset < length; offset++) {
+                                            if (serString[offset] < '0' || serString[offset] > '9') {
+                                                break;
+                                            }
+                                        }
+                                    }
+
+                                    if (length > offset) {
+                                        if (serString[offset] != 'Z') {
+                                            if ((serString[offset] != '+' && serString[offset] != '-')
+                                                    || (serString[offset + 3] != ':'))
+                                                throw new AlgebricksException(errorMessage);
+
+                                            short timezoneHour = 0;
+                                            short timezoneMinute = 0;
+
+                                            for (int i = 0; i < 2; i++) {
+                                                if ((serString[offset + 1 + i] >= '0' && serString[offset + 1 + i] <= '9'))
+                                                    timezoneHour = (short) (timezoneHour * 10
+                                                            + serString[offset + 1 + i] - '0');
+                                                else
+                                                    throw new AlgebricksException(errorMessage);
+
+                                            }
+
+                                            if (timezoneHour < GregorianCalendarSystem.TIMEZONE_HOUR_MIN
+                                                    || timezoneHour > GregorianCalendarSystem.TIMEZONE_HOUR_MAX) {
+                                                throw new AlgebricksException(errorMessage + ": time zone hour "
+                                                        + timezoneHour);
+                                            }
+
+                                            for (int i = 0; i < 2; i++) {
+                                                if ((serString[offset + 4 + i] >= '0' && serString[offset + 4 + i] <= '9'))
+                                                    timezoneMinute = (short) (timezoneMinute * 10
+                                                            + serString[offset + 4 + i] - '0');
+                                                else
+                                                    throw new AlgebricksException(errorMessage);
+                                            }
+
+                                            if (timezoneMinute < GregorianCalendarSystem.TIMEZONE_MIN_MIN
+                                                    || timezoneMinute > GregorianCalendarSystem.TIMEZONE_MIN_MAX) {
+                                                throw new AlgebricksException(errorMessage + ": time zone minute "
+                                                        + timezoneMinute);
+                                            }
+
+                                            if (serString[offset] == '-')
+                                                timezone = (byte) -((timezoneHour * 4) + timezoneMinute / 15);
+                                            else
+                                                timezone = (byte) ((timezoneHour * 4) + timezoneMinute / 15);
+                                        }
+                                    }
+
+                                } else {
+                                    // parse basic form
+                                    if (serString[offset] == '-') {
+                                        offset++;
+                                        positive = false;
+                                    }
+
+                                    // year
+                                    for (int i = 0; i < 4; i++) {
+                                        if ((serString[offset + i] >= '0' && serString[offset + i] <= '9')) {
+                                            year = year * 10 + serString[offset + i] - '0';
+                                        } else {
+                                            throw new AlgebricksException(errorMessage);
+                                        }
+                                    }
+
+                                    if (year < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.YEAR]
+                                            || year > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.YEAR]) {
+                                        throw new AlgebricksException(errorMessage + ": year " + year);
+                                    }
+
+                                    offset += 4;
+
+                                    // month
+                                    for (int i = 0; i < 2; i++) {
+                                        if ((serString[offset + i] >= '0' && serString[offset + i] <= '9')) {
+                                            month = month * 10 + serString[offset + i] - '0';
+                                        } else {
+                                            throw new AlgebricksException(errorMessage);
+                                        }
+                                    }
+
+                                    if (month < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.MONTH]
+                                            || month > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.MONTH]) {
+                                        throw new AlgebricksException(errorMessage + ": month " + month);
+                                    }
+
+                                    offset += 2;
+
+                                    // day
+                                    for (int i = 0; i < 2; i++) {
+                                        if ((serString[offset + i] >= '0' && serString[offset + i] <= '9')) {
+                                            day = day * 10 + serString[offset + i] - '0';
+                                        } else {
+                                            throw new AlgebricksException(errorMessage);
+                                        }
+                                    }
+
+                                    if (day < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.DAY]
+                                            || day > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.DAY]) {
+                                        throw new AlgebricksException(errorMessage + ": day " + day);
+                                    }
+
+                                    offset += 2;
+
+                                    if (!positive)
+                                        year *= -1;
+
+                                    // hour
+                                    for (int i = 0; i < 2; i++) {
+                                        if ((serString[offset + i] >= '0' && serString[offset + i] <= '9')) {
+                                            hour = hour * 10 + serString[offset + i] - '0';
+                                        } else {
+                                            throw new AlgebricksException(errorMessage);
+                                        }
+                                    }
+
+                                    if (hour < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.HOUR]
+                                            || hour > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.HOUR]) {
+                                        throw new AlgebricksException(errorMessage + ": hour " + hour);
+                                    }
+
+                                    offset += 2;
+
+                                    // minute
+                                    for (int i = 0; i < 2; i++) {
+                                        if ((serString[offset + i] >= '0' && serString[offset + i] <= '9')) {
+                                            min = min * 10 + serString[offset + i] - '0';
+                                        } else {
+                                            throw new AlgebricksException(errorMessage);
+                                        }
+                                    }
+
+                                    if (min < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.MINUTE]
+                                            || min > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.MINUTE]) {
+                                        throw new AlgebricksException(errorMessage + ": min " + min);
+                                    }
+
+                                    offset += 2;
+
+                                    // second
+                                    for (int i = 0; i < 2; i++) {
+                                        if ((serString[offset + i] >= '0' && serString[offset + i] <= '9')) {
+                                            sec = sec * 10 + serString[offset + i] - '0';
+                                        } else {
+                                            throw new AlgebricksException(errorMessage);
+                                        }
+                                    }
+
+                                    if (sec < GregorianCalendarSystem.FIELD_MINS[GregorianCalendarSystem.SECOND]
+                                            || sec > GregorianCalendarSystem.FIELD_MAXS[GregorianCalendarSystem.SECOND]) {
+                                        throw new AlgebricksException(errorMessage + ": sec " + sec);
+                                    }
+
+                                    offset += 2;
+
+                                    if (length > offset) {
+                                        int i = 0;
+                                        for (; i < 3 && offset + i < length; i++) {
+                                            if (serString[offset + i] >= '0' && serString[offset + i] <= '9') {
+                                                millis = millis * 10 + serString[offset + i] - '0';
+                                            } else {
+                                                break;
+                                            }
+                                        }
+
+                                        offset += i;
+
+                                        for (; i < 3; i++) {
+                                            millis = millis * 10;
+                                        }
+
+                                        for (; offset < length; offset++) {
+                                            if (serString[offset] < '0' || serString[offset] > '9') {
+                                                break;
+                                            }
+                                        }
+                                    }
+
+                                    if (length > offset) {
+                                        if (serString[offset] != 'Z') {
+                                            if ((serString[offset] != '+' && serString[offset] != '-'))
+                                                throw new AlgebricksException(errorMessage);
+
+                                            short timezoneHour = 0;
+                                            short timezoneMinute = 0;
+
+                                            for (int i = 0; i < 2; i++) {
+                                                if ((serString[offset + 1 + i] >= '0' && serString[offset + 1 + i] <= '9'))
+                                                    timezoneHour = (short) (timezoneHour * 10
+                                                            + serString[offset + 1 + i] - '0');
+                                                else
+                                                    throw new AlgebricksException(errorMessage);
+
+                                            }
+
+                                            if (timezoneHour < GregorianCalendarSystem.TIMEZONE_HOUR_MIN
+                                                    || timezoneHour > GregorianCalendarSystem.TIMEZONE_HOUR_MAX) {
+                                                throw new AlgebricksException(errorMessage + ": time zone hour "
+                                                        + timezoneHour);
+                                            }
+
+                                            for (int i = 0; i < 2; i++) {
+                                                if ((serString[offset + 3 + i] >= '0' && serString[offset + 3 + i] <= '9'))
+                                                    timezoneMinute = (short) (timezoneMinute * 10
+                                                            + serString[offset + 3 + i] - '0');
+                                                else
+                                                    throw new AlgebricksException(errorMessage);
+                                            }
+
+                                            if (timezoneMinute < GregorianCalendarSystem.TIMEZONE_MIN_MIN
+                                                    || timezoneMinute > GregorianCalendarSystem.TIMEZONE_MIN_MAX) {
+                                                throw new AlgebricksException(errorMessage + ": time zone minute "
+                                                        + timezoneMinute);
+                                            }
+
+                                            if (serString[offset] == '-')
+                                                timezone = (byte) -((timezoneHour * 4) + timezoneMinute / 15);
+                                            else
+                                                timezone = (byte) ((timezoneHour * 4) + timezoneMinute / 15);
+                                        }
+                                    }
+                                }
+
+                                aDateTime.setValue(gCalInstance.getChronon(year, month, day, hour, min, sec,
+                                        (int) millis, timezone));
+
                                 datetimeSerde.serialize(aDateTime, out);
                             } else if (serString[0] == SER_NULL_TYPE_TAG)
                                 nullSerde.serialize(ANull.NULL, out);
diff --git a/asterix-runtime/src/main/java/edu/uci/ics/asterix/runtime/evaluators/constructors/ADurationConstructorDescriptor.java b/asterix-runtime/src/main/java/edu/uci/ics/asterix/runtime/evaluators/constructors/ADurationConstructorDescriptor.java
index c510c4d..ab8e8d0 100644
--- a/asterix-runtime/src/main/java/edu/uci/ics/asterix/runtime/evaluators/constructors/ADurationConstructorDescriptor.java
+++ b/asterix-runtime/src/main/java/edu/uci/ics/asterix/runtime/evaluators/constructors/ADurationConstructorDescriptor.java
@@ -42,9 +42,10 @@
                     private ArrayBackedValueStorage outInput = new ArrayBackedValueStorage();
                     private IEvaluator eval = args[0].createEvaluator(outInput);
                     private int offset;
-                    private int value = 0, hour = 0, minute = 0, second = 0, year = 0, month = 0, day = 0;
+                    private int value = 0, hour = 0, minute = 0, second = 0, millisecond = 0, year = 0, month = 0,
+                            day = 0;
                     private boolean isYear = true, isMonth = true, isDay = true, isHour = true, isMinute = true,
-                            isSecond = true, isTime = false, timeItem = true, positive = true;
+                            isSecond = true, isMillisecond = true, isTime = false, timeItem = true, positive = true;
                     private String errorMessage = "This can not be an instance of duration";
                     private AMutableDuration aDuration = new AMutableDuration(0, 0);
                     @SuppressWarnings("unchecked")
@@ -67,7 +68,7 @@
                                     offset++;
                                     positive = false;
                                 }
-                                if (serString[offset++] != 'D')
+                                if (serString[offset++] != 'P')
                                     throw new AlgebricksException(errorMessage);
 
                                 for (; offset < outInput.getLength(); offset++) {
@@ -85,33 +86,21 @@
                                             case 'M':
                                                 if (!isTime) {
                                                     if (isMonth) {
-                                                        if (value < 0 || value > 11)
-                                                            throw new AlgebricksException(errorMessage);
-                                                        else {
-                                                            month = value;
-                                                            isMonth = false;
-                                                        }
+                                                        month = value;
+                                                        isMonth = false;
                                                     } else
                                                         throw new AlgebricksException(errorMessage);
                                                 } else if (isMinute) {
-                                                    if (value < 0 || value > 59)
-                                                        throw new AlgebricksException(errorMessage);
-                                                    else {
-                                                        minute = value;
-                                                        isMinute = false;
-                                                        timeItem = false;
-                                                    }
+                                                    minute = value;
+                                                    isMinute = false;
+                                                    timeItem = false;
                                                 } else
                                                     throw new AlgebricksException(errorMessage);
                                                 break;
                                             case 'D':
                                                 if (isDay) {
-                                                    if (value < 0 || value > 30)
-                                                        throw new AlgebricksException(errorMessage);
-                                                    else {
-                                                        day = value;
-                                                        isDay = false;
-                                                    }
+                                                    day = value;
+                                                    isDay = false;
                                                 } else
                                                     throw new AlgebricksException(errorMessage);
                                                 break;
@@ -125,25 +114,34 @@
 
                                             case 'H':
                                                 if (isHour) {
-                                                    if (value < 0 || value > 23)
-                                                        throw new AlgebricksException(errorMessage);
-                                                    else {
-                                                        hour = value;
-                                                        isHour = false;
-                                                        timeItem = false;
-                                                    }
+                                                    hour = value;
+                                                    isHour = false;
+                                                    timeItem = false;
                                                 } else
                                                     throw new AlgebricksException(errorMessage);
                                                 break;
+                                            case '.':
+                                                if (isMillisecond) {
+                                                    int i = 1;
+                                                    for (; offset + i < outInput.getLength(); i++) {
+                                                        if (serString[offset + i] >= '0'
+                                                                && serString[offset + i] <= '9') {
+                                                            if (i < 4)
+                                                                millisecond = millisecond * 10 + serString[offset + i]
+                                                                        - '0';
+                                                        } else
+                                                            break;
+                                                    }
+                                                    offset += i;
+                                                    isMillisecond = false;
+                                                    timeItem = false;
+                                                } else
+                                                    throw new AlgebricksException(errorMessage);
                                             case 'S':
                                                 if (isSecond) {
-                                                    if (value < 0 || value > 59)
-                                                        throw new AlgebricksException(errorMessage);
-                                                    else {
-                                                        second = value;
-                                                        isSecond = false;
-                                                        timeItem = false;
-                                                    }
+                                                    second = value;
+                                                    isSecond = false;
+                                                    timeItem = false;
                                                 } else
                                                     throw new AlgebricksException(errorMessage);
                                                 break;
@@ -158,15 +156,16 @@
                                 if (isTime && timeItem)
                                     throw new AlgebricksException(errorMessage);
 
-                                if (isYear && isMonth && isDay && !isTime)
-                                    throw new AlgebricksException(errorMessage);
+                                //                                if (isYear && isMonth && isDay && !isTime)
+                                //                                    throw new AlgebricksException(errorMessage);
 
                                 if (positive)
-                                    aDuration.setValue(year * 12 + month, day * 24 * 3600 + 3600 * hour + 60 * minute
-                                            + second);
+                                    aDuration.setValue(year * 12 + month, day * 24 * 3600 * 1000L + 3600 * 1000L * hour
+                                            + 60 * minute * 1000L + second * 1000L + millisecond);
                                 else
                                     aDuration.setValue(-1 * (year * 12 + month), -1
-                                            * (day * 24 * 3600 + 3600 * hour + 60 * minute + second));
+                                            * (day * 24 * 3600 * 1000L + 3600 * 1000L * hour + 60 * minute * 1000L
+                                                    + second * 1000L + millisecond));
                                 durationSerde.serialize(aDuration, out);
                             } else if (serString[0] == SER_NULL_TYPE_TAG)
                                 nullSerde.serialize(ANull.NULL, out);
diff --git a/asterix-runtime/src/main/java/edu/uci/ics/asterix/runtime/evaluators/constructors/ATimeConstructorDescriptor.java b/asterix-runtime/src/main/java/edu/uci/ics/asterix/runtime/evaluators/constructors/ATimeConstructorDescriptor.java
index f2926cd..9850aa3 100644
--- a/asterix-runtime/src/main/java/edu/uci/ics/asterix/runtime/evaluators/constructors/ATimeConstructorDescriptor.java
+++ b/asterix-runtime/src/main/java/edu/uci/ics/asterix/runtime/evaluators/constructors/ATimeConstructorDescriptor.java
@@ -59,14 +59,242 @@
                             eval.evaluate(tuple);
                             byte[] serString = outInput.getBytes();
                             if (serString[0] == SER_STRING_TYPE_TAG) {
+
                                 offset = 3;
-                                int length=3;
-                                
-                                while (serString[length]!='\0')
-                                	length++;
-                                
-                                GregorianCalendarSystem.getInstance().parseStringForATime(serString, offset, length, aTime);
-                                
+
+                                int length = ((serString[1] & 0xff) << 8) + ((serString[2] & 0xff) << 0) + 3;
+
+                                int hour = 0, min = 0, sec = 0, millis = 0;
+                                int timezone = 0;
+                                boolean isExtendedForm = false;
+                                if (serString[offset + 2] == ':') {
+                                    isExtendedForm = true;
+                                }
+                                if (isExtendedForm) {
+                                    // parse extended form
+                                    if (serString[offset] == '-' || serString[offset + 5] != ':')
+                                        throw new AlgebricksException(errorMessage);
+
+                                    for (int i = 0; i < 2; i++) {
+                                        if ((serString[offset + i] >= '0' && serString[offset + i] <= '9'))
+                                            hour = hour * 10 + serString[offset + i] - '0';
+                                        else
+                                            throw new AlgebricksException(errorMessage);
+
+                                    }
+
+                                    if (hour < 0 || hour > 23) {
+                                        throw new AlgebricksException(errorMessage + ": hour " + hour);
+                                    }
+
+                                    offset += 3;
+
+                                    for (int i = 0; i < 2; i++) {
+                                        if ((serString[offset + i] >= '0' && serString[offset + i] <= '9'))
+                                            min = min * 10 + serString[offset + i] - '0';
+                                        else
+                                            throw new AlgebricksException(errorMessage);
+
+                                    }
+
+                                    if (min < 0 || min > 59) {
+                                        throw new AlgebricksException(errorMessage + ": min " + min);
+                                    }
+
+                                    offset += 3;
+
+                                    for (int i = 0; i < 2; i++) {
+                                        if ((serString[offset + i] >= '0' && serString[offset + i] <= '9'))
+                                            sec = sec * 10 + serString[offset + i] - '0';
+                                        else
+                                            throw new AlgebricksException(errorMessage);
+
+                                    }
+
+                                    if (sec < 0 || sec > 59) {
+                                        throw new AlgebricksException(errorMessage + ": sec " + sec);
+                                    }
+
+                                    offset += 2;
+
+                                    if (length > offset && serString[offset] == '.') {
+
+                                        offset++;
+                                        int i = 0;
+                                        for (; i < 3 && offset + i < length; i++) {
+                                            if (serString[offset + i] >= '0' && serString[offset + i] <= '9') {
+                                                millis = millis * 10 + serString[offset + i] - '0';
+                                            } else {
+                                                break;
+                                            }
+                                        }
+
+                                        offset += i;
+
+                                        for (; i < 3; i++) {
+                                            millis = millis * 10;
+                                        }
+
+                                        for (; offset < length; offset++) {
+                                            if (serString[offset] < '0' || serString[offset] > '9') {
+                                                break;
+                                            }
+                                        }
+                                    }
+
+                                    if (length > offset) {
+                                        if (serString[offset] != 'Z') {
+                                            if ((serString[offset] != '+' && serString[offset] != '-')
+                                                    || (serString[offset + 3] != ':'))
+                                                throw new AlgebricksException(errorMessage);
+
+                                            short timezoneHour = 0;
+                                            short timezoneMinute = 0;
+
+                                            for (int i = 0; i < 2; i++) {
+                                                if ((serString[offset + 1 + i] >= '0' && serString[offset + 1 + i] <= '9'))
+                                                    timezoneHour = (short) (timezoneHour * 10
+                                                            + serString[offset + 1 + i] - '0');
+                                                else
+                                                    throw new AlgebricksException(errorMessage);
+
+                                            }
+
+                                            if (timezoneHour < GregorianCalendarSystem.TIMEZONE_HOUR_MIN
+                                                    || timezoneHour > GregorianCalendarSystem.TIMEZONE_HOUR_MAX) {
+                                                throw new AlgebricksException(errorMessage + ": time zone hour "
+                                                        + timezoneHour);
+                                            }
+
+                                            for (int i = 0; i < 2; i++) {
+                                                if ((serString[offset + 4 + i] >= '0' && serString[offset + 4 + i] <= '9'))
+                                                    timezoneMinute = (short) (timezoneMinute * 10
+                                                            + serString[offset + 4 + i] - '0');
+                                                else
+                                                    throw new AlgebricksException(errorMessage);
+                                            }
+
+                                            if (timezoneMinute < GregorianCalendarSystem.TIMEZONE_MIN_MIN
+                                                    || timezoneMinute > GregorianCalendarSystem.TIMEZONE_MIN_MAX) {
+                                                throw new AlgebricksException(errorMessage + ": time zone minute "
+                                                        + timezoneMinute);
+                                            }
+
+                                            if (serString[offset] == '-')
+                                                timezone = (byte) -((timezoneHour * 4) + timezoneMinute / 15);
+                                            else
+                                                timezone = (byte) ((timezoneHour * 4) + timezoneMinute / 15);
+                                        }
+                                    }
+
+                                } else {
+                                    // parse basic form
+
+                                    if (serString[offset] == '-')
+                                        throw new AlgebricksException(errorMessage);
+
+                                    for (int i = 0; i < 2; i++) {
+                                        if ((serString[offset + i] >= '0' && serString[offset + i] <= '9'))
+                                            hour = hour * 10 + serString[offset + i] - '0';
+                                        else
+                                            throw new AlgebricksException(errorMessage);
+
+                                    }
+
+                                    if (hour < 0 || hour > 23) {
+                                        throw new AlgebricksException(errorMessage + ": hour " + hour);
+                                    }
+
+                                    offset += 2;
+
+                                    for (int i = 0; i < 2; i++) {
+                                        if ((serString[offset + i] >= '0' && serString[offset + i] <= '9'))
+                                            min = min * 10 + serString[offset + i] - '0';
+                                        else
+                                            throw new AlgebricksException(errorMessage);
+
+                                    }
+
+                                    if (min < 0 || min > 59) {
+                                        throw new AlgebricksException(errorMessage + ": min " + min);
+                                    }
+
+                                    offset += 2;
+
+                                    for (int i = 0; i < 2; i++) {
+                                        if ((serString[offset + i] >= '0' && serString[offset + i] <= '9'))
+                                            sec = sec * 10 + serString[offset + i] - '0';
+                                        else
+                                            throw new AlgebricksException(errorMessage);
+
+                                    }
+
+                                    if (sec < 0 || sec > 59) {
+                                        throw new AlgebricksException(errorMessage + ": sec " + sec);
+                                    }
+
+                                    offset += 2;
+
+                                    if (length > offset) {
+                                        int i = 0;
+                                        for (; i < 3 && offset + i < length; i++) {
+                                            if ((serString[offset + i] >= '0' && serString[offset + i] <= '9')) {
+                                                millis = millis * 10 + serString[offset + i] - '0';
+                                            } else {
+                                                break;
+                                            }
+                                        }
+
+                                        offset += i;
+
+                                        for (; i < 3; i++) {
+                                            millis = millis * 10;
+                                        }
+
+                                        for (; offset < length; offset++) {
+                                            if (serString[offset] < '0' || serString[offset] > '9') {
+                                                break;
+                                            }
+                                        }
+                                    }
+
+                                    if (length > offset) {
+                                        if (serString[offset] != 'Z') {
+                                            if ((serString[offset] != '+' && serString[offset] != '-'))
+                                                throw new AlgebricksException(errorMessage);
+
+                                            short timezoneHour = 0;
+                                            short timezoneMinute = 0;
+
+                                            for (int i = 0; i < 2; i++) {
+                                                if ((serString[offset + 1 + i] >= '0' && serString[offset + 1 + i] <= '9'))
+                                                    timezoneHour = (short) (timezoneHour * 10
+                                                            + serString[offset + 1 + i] - '0');
+                                                else
+                                                    throw new AlgebricksException(errorMessage);
+
+                                            }
+
+                                            for (int i = 0; i < 2; i++) {
+                                                if ((serString[offset + 3 + i] >= '0' && serString[offset + 3 + i] <= '9'))
+                                                    timezoneMinute = (short) (timezoneMinute * 10
+                                                            + serString[offset + 3 + i] - '0');
+                                                else
+                                                    throw new AlgebricksException(errorMessage);
+
+                                            }
+
+                                            if (serString[offset] == '-')
+                                                timezone = (byte) -((timezoneHour * 4) + timezoneMinute / 15);
+                                            else
+                                                timezone = (byte) ((timezoneHour * 4) + timezoneMinute / 15);
+                                        }
+                                    }
+                                }
+
+                                aTime.setValue(GregorianCalendarSystem.getInstance().getChronon(hour, min, sec, millis,
+                                        timezone));
+
                                 timeSerde.serialize(aTime, out);
 
                             } else if (serString[0] == SER_NULL_TYPE_TAG)