zeoslib  UNKNOWN
 All Files
ZFunctionsDateTime.pas
Go to the documentation of this file.
1 {*********************************************************}
2 { }
3 { Zeos Database Objects }
4 { Variables classes and interfaces }
5 { }
6 { Originally written by Sergey Seroukhov }
7 { }
8 {*********************************************************}
9 
10 {@********************************************************}
11 { Copyright (c) 1999-2012 Zeos Development Group }
12 { }
13 { License Agreement: }
14 { }
15 { This library is distributed in the hope that it will be }
16 { useful, but WITHOUT ANY WARRANTY; without even the }
17 { implied warranty of MERCHANTABILITY or FITNESS FOR }
18 { A PARTICULAR PURPOSE. See the GNU Lesser General }
19 { Public License for more details. }
20 { }
21 { The source code of the ZEOS Libraries and packages are }
22 { distributed under the Library GNU General Public }
23 { License (see the file COPYING / COPYING.ZEOS) }
24 { with the following modification: }
25 { As a special exception, the copyright holders of this }
26 { library give you permission to link this library with }
27 { independent modules to produce an executable, }
28 { regardless of the license terms of these independent }
29 { modules, and to copy and distribute the resulting }
30 { executable under terms of your choice, provided that }
31 { you also meet, for each linked independent module, }
32 { the terms and conditions of the license of that module. }
33 { An independent module is a module which is not derived }
34 { from or based on this library. If you modify this }
35 { library, you may extend this exception to your version }
36 { of the library, but you are not obligated to do so. }
37 { If you do not wish to do so, delete this exception }
38 { statement from your version. }
39 { }
40 { }
41 { The project web site is located on: }
42 { http://zeos.firmos.at (FORUM) }
43 { http://sourceforge.net/p/zeoslib/tickets/ (BUGTRACKER)}
44 { svn://svn.code.sf.net/p/zeoslib/code-0/trunk (SVN) }
45 { }
46 { http://www.sourceforge.net/projects/zeoslib. }
47 { }
48 { }
49 { Zeos Development Group. }
50 {********************************************************@}
51 
52 unit ZFunctionsDateTime;
53 
54 interface
55 
56 {$I ZCore.inc}
57 
58 uses
59  SysUtils, ZFunctions, ZExpression, ZVariant;
60 
61 {** Date & time functions}
62 
63 type
64  {** Implements a DATE function. }
65  TZDateFunction = class (TZAbstractFunction)
66  public
67  function Execute(Stack: TZExecutionStack;
68  VariantManager: IZVariantManager): TZVariant; override;
69  end;
70 
71  {** Implements a TIME function. }
72  TZTimeFunction = class (TZAbstractFunction)
73  public
74  function Execute(Stack: TZExecutionStack;
75  VariantManager: IZVariantManager): TZVariant; override;
76  end;
77 
78  {** Implements a NOW function. }
79  TZNowFunction = class (TZAbstractFunction)
80  public
81  function Execute(Stack: TZExecutionStack;
82  VariantManager: IZVariantManager): TZVariant; override;
83  end;
84 
85  {** Implements a ENCODEDATE function. }
86  TZEncodeDateFunction = class (TZAbstractFunction)
87  public
88  function Execute(Stack: TZExecutionStack;
89  VariantManager: IZVariantManager): TZVariant; override;
90  end;
91 
92  {** Implements a ENCODETIME function. }
93  TZEncodeTimeFunction = class (TZAbstractFunction)
94  public
95  function Execute(Stack: TZExecutionStack;
96  VariantManager: IZVariantManager): TZVariant; override;
97  end;
98 
99  {** Implements a COMPOSEDATETIME function. }
100 
101  { TZComposeDateTimeFunction }
102 
103  TZComposeDateTimeFunction = class (TZAbstractFunction)
104  public
105  function Execute(Stack: TZExecutionStack;
106  VariantManager: IZVariantManager): TZVariant; override;
107  end;
108 
109  {** Implements a INCDATE function. }
110  TZIncDateFunction = class (TZAbstractFunction)
111  public
112  function Execute(Stack: TZExecutionStack;
113  VariantManager: IZVariantManager): TZVariant; override;
114  end;
115 
116  {** Implements a INCTIME function. }
117  TZIncTimeFunction = class (TZAbstractFunction)
118  public
119  function Execute(Stack: TZExecutionStack;
120  VariantManager: IZVariantManager): TZVariant; override;
121  end;
122 
123  {** Implements a ISLEAPYEAR function. }
124  TZIsLeapYearFunction = class (TZAbstractFunction)
125  public
126  function Execute(Stack: TZExecutionStack;
127  VariantManager: IZVariantManager): TZVariant; override;
128  end;
129 
130 {-------------------- Extracting functions ----------------------------}
131  {** Implements a DATEOF function. }
132  TZDateOfFunction = class (TZAbstractFunction)
133  public
134  function Execute(Stack: TZExecutionStack;
135  VariantManager: IZVariantManager): TZVariant; override;
136  end;
137 
138  {** Implements a TIMEOF function. }
139  TZTimeOfFunction = class (TZAbstractFunction)
140  public
141  function Execute(Stack: TZExecutionStack;
142  VariantManager: IZVariantManager): TZVariant; override;
143  end;
144 
145  {** Implements a YEAROF function. }
146  TZYearOfFunction = class (TZAbstractFunction)
147  public
148  function Execute(Stack: TZExecutionStack;
149  VariantManager: IZVariantManager): TZVariant; override;
150  end;
151 
152  {** Implements a MONTHOF function. }
153  TZMonthOfFunction = class (TZAbstractFunction)
154  public
155  function Execute(Stack: TZExecutionStack;
156  VariantManager: IZVariantManager): TZVariant; override;
157  end;
158 
159  {** Implements a DAYOF function. }
160  TZDayOfFunction = class (TZAbstractFunction)
161  public
162  function Execute(Stack: TZExecutionStack;
163  VariantManager: IZVariantManager): TZVariant; override;
164  end;
165 
166  {** Implements a HOUROF function. }
167  TZHourOfFunction = class (TZAbstractFunction)
168  public
169  function Execute(Stack: TZExecutionStack;
170  VariantManager: IZVariantManager): TZVariant; override;
171  end;
172 
173  {** Implements a MINUTEOF function. }
174  TZMinuteOfFunction = class (TZAbstractFunction)
175  public
176  function Execute(Stack: TZExecutionStack;
177  VariantManager: IZVariantManager): TZVariant; override;
178  end;
179 
180  {** Implements a SECONDOF function. }
181  TZSecondOfFunction = class (TZAbstractFunction)
182  public
183  function Execute(Stack: TZExecutionStack;
184  VariantManager: IZVariantManager): TZVariant; override;
185  end;
186 
187  {** Implements a MILLISECONDOF function. }
188  TZMilliSecondOfFunction = class (TZAbstractFunction)
189  public
190  function Execute(Stack: TZExecutionStack;
191  VariantManager: IZVariantManager): TZVariant; override;
192  end;
193 
194 {-------------------- *OFTHEYEAR Extracting functions ----------------------------}
195  {** Implements a WEEKOFTHEYEAR function. }
196  TZWeekOfTheYearFunction = class (TZAbstractFunction)
197  public
198  function Execute(Stack: TZExecutionStack;
199  VariantManager: IZVariantManager): TZVariant; override;
200  end;
201 
202  {** Implements a DAYOFTHEYEAR function. }
203  TZDayOfTheYearFunction = class (TZAbstractFunction)
204  public
205  function Execute(Stack: TZExecutionStack;
206  VariantManager: IZVariantManager): TZVariant; override;
207  end;
208 
209  {** Implements a HOUROFTHEYEAR function. }
210  TZHourOfTheYearFunction = class (TZAbstractFunction)
211  public
212  function Execute(Stack: TZExecutionStack;
213  VariantManager: IZVariantManager): TZVariant; override;
214  end;
215 
216  {** Implements a MINUTEOFTHEYEAR function. }
217  TZMinuteOfTheYearFunction = class (TZAbstractFunction)
218  public
219  function Execute(Stack: TZExecutionStack;
220  VariantManager: IZVariantManager): TZVariant; override;
221  end;
222 
223  {** Implements a SECONDOFTHEYEAR function. }
224  TZSecondOfTheYearFunction = class (TZAbstractFunction)
225  public
226  function Execute(Stack: TZExecutionStack;
227  VariantManager: IZVariantManager): TZVariant; override;
228  end;
229 
230  {** Implements a MILLISECONDOFTHEYEAR function. }
231  TZMilliSecondOfTheYearFunction = class (TZAbstractFunction)
232  public
233  function Execute(Stack: TZExecutionStack;
234  VariantManager: IZVariantManager): TZVariant; override;
235  end;
236 
237 {-------------------- *OFTHEMONTH Extracting functions ----------------------------}
238  {** Implements a WEEKOFTHEMONTH function. }
239  TZWeekOfTheMonthFunction = class (TZAbstractFunction)
240  public
241  function Execute(Stack: TZExecutionStack;
242  VariantManager: IZVariantManager): TZVariant; override;
243  end;
244 
245  {** Implements a HOUROFTHEMONTH function. }
246  TZHourOfTheMonthFunction = class (TZAbstractFunction)
247  public
248  function Execute(Stack: TZExecutionStack;
249  VariantManager: IZVariantManager): TZVariant; override;
250  end;
251 
252  {** Implements a MINUTEOFTHEMONTH function. }
253  TZMinuteOfTheMonthFunction = class (TZAbstractFunction)
254  public
255  function Execute(Stack: TZExecutionStack;
256  VariantManager: IZVariantManager): TZVariant; override;
257  end;
258 
259  {** Implements a SECONDOFTHEMONTH function. }
260  TZSecondOfTheMonthFunction = class (TZAbstractFunction)
261  public
262  function Execute(Stack: TZExecutionStack;
263  VariantManager: IZVariantManager): TZVariant; override;
264  end;
265 
266  {** Implements a MILLISECONDOFTHEMONTH function. }
267  TZMilliSecondOfTheMonthFunction = class (TZAbstractFunction)
268  public
269  function Execute(Stack: TZExecutionStack;
270  VariantManager: IZVariantManager): TZVariant; override;
271  end;
272 
273 {-------------------- *OFTHEWEEK Extracting functions ----------------------------}
274  {** Implements a DAYOfTheWeek function. }
275  TZDayOfTheWeekFunction = class (TZAbstractFunction)
276  public
277  function Execute(Stack: TZExecutionStack;
278  VariantManager: IZVariantManager): TZVariant; override;
279  end;
280 
281  {** Implements a HOUROfTheWeek function. }
282  TZHourOfTheWeekFunction = class (TZAbstractFunction)
283  public
284  function Execute(Stack: TZExecutionStack;
285  VariantManager: IZVariantManager): TZVariant; override;
286  end;
287 
288  {** Implements a MINUTEOfTheWeek function. }
289  TZMinuteOfTheWeekFunction = class (TZAbstractFunction)
290  public
291  function Execute(Stack: TZExecutionStack;
292  VariantManager: IZVariantManager): TZVariant; override;
293  end;
294 
295  {** Implements a SECONDOfTheWeek function. }
296  TZSecondOfTheWeekFunction = class (TZAbstractFunction)
297  public
298  function Execute(Stack: TZExecutionStack;
299  VariantManager: IZVariantManager): TZVariant; override;
300  end;
301 
302  {** Implements a MILLISECONDOfTheWeek function. }
303  TZMilliSecondOfTheWeekFunction = class (TZAbstractFunction)
304  public
305  function Execute(Stack: TZExecutionStack;
306  VariantManager: IZVariantManager): TZVariant; override;
307  end;
308 
309 
310 {---------------- *OFTHEDAY Extracting functions --------------------}
311  {** Implements a MINUTEOFTHEDAY function. }
312  TZMinuteOfTheDayFunction = class (TZAbstractFunction)
313  public
314  function Execute(Stack: TZExecutionStack;
315  VariantManager: IZVariantManager): TZVariant; override;
316  end;
317 
318  {** Implements a SECONDOFTHEDAY function. }
319  TZSecondOfTheDayFunction = class (TZAbstractFunction)
320  public
321  function Execute(Stack: TZExecutionStack;
322  VariantManager: IZVariantManager): TZVariant; override;
323  end;
324 
325  {** Implements a MILLISECONDOFTHEDAY function. }
326  TZMilliSecondOfTheDayFunction = class (TZAbstractFunction)
327  public
328  function Execute(Stack: TZExecutionStack;
329  VariantManager: IZVariantManager): TZVariant; override;
330  end;
331 
332 {---------------- *OfTheHour Extracting functions --------------------}
333  {** Implements a SECONDOFTHEHOUR function. }
334  TZSecondOfTheHourFunction = class (TZAbstractFunction)
335  public
336  function Execute(Stack: TZExecutionStack;
337  VariantManager: IZVariantManager): TZVariant; override;
338  end;
339 
340  {** Implements a MILLISECONDOFTHEHOUR function. }
341  TZMilliSecondOfTheHourFunction = class (TZAbstractFunction)
342  public
343  function Execute(Stack: TZExecutionStack;
344  VariantManager: IZVariantManager): TZVariant; override;
345  end;
346 
347 {---------------- *OFTHEMINUTE Extracting functions --------------------}
348  {** Implements a MILLISECONDOfTheHour function. }
349  TZMilliSecondOfTheMinuteFunction = class (TZAbstractFunction)
350  public
351  function Execute(Stack: TZExecutionStack;
352  VariantManager: IZVariantManager): TZVariant; override;
353  end;
354 
355 {---------------- *BETWEEN functions --------------------}
356  {** Implements a YEARSBETWEEN function. }
357  TZYearsBetweenFunction = class (TZAbstractFunction)
358  public
359  function Execute(Stack: TZExecutionStack;
360  VariantManager: IZVariantManager): TZVariant; override;
361  end;
362 
363  {** Implements a MONTHSBETWEEN function. }
364  TZMonthsBetweenFunction = class (TZAbstractFunction)
365  public
366  function Execute(Stack: TZExecutionStack;
367  VariantManager: IZVariantManager): TZVariant; override;
368  end;
369 
370  {** Implements a WEEKSBETWEEN function. }
371  TZWeeksBetweenFunction = class (TZAbstractFunction)
372  public
373  function Execute(Stack: TZExecutionStack;
374  VariantManager: IZVariantManager): TZVariant; override;
375  end;
376 
377  {** Implements a DAYSBETWEEN function. }
378  TZDaysBetweenFunction = class (TZAbstractFunction)
379  public
380  function Execute(Stack: TZExecutionStack;
381  VariantManager: IZVariantManager): TZVariant; override;
382  end;
383 
384  {** Implements a HOURSBETWEEN function. }
385  TZHoursBetweenFunction = class (TZAbstractFunction)
386  public
387  function Execute(Stack: TZExecutionStack;
388  VariantManager: IZVariantManager): TZVariant; override;
389  end;
390 
391  {** Implements a MINUTESBETWEEN function. }
392  TZMinutesBetweenFunction = class (TZAbstractFunction)
393  public
394  function Execute(Stack: TZExecutionStack;
395  VariantManager: IZVariantManager): TZVariant; override;
396  end;
397 
398  {** Implements a SECONDSBETWEEN function. }
399  TZSecondsBetweenFunction = class (TZAbstractFunction)
400  public
401  function Execute(Stack: TZExecutionStack;
402  VariantManager: IZVariantManager): TZVariant; override;
403  end;
404 
405  {** Implements a MILLISECONDSBETWEEN function. }
406  TZMillisecondsBetweenFunction = class (TZAbstractFunction)
407  public
408  function Execute(Stack: TZExecutionStack;
409  VariantManager: IZVariantManager): TZVariant; override;
410  end;
411 
412 procedure AddDateTimeFunctions(Functions : TZFunctionsList);
413 
414 implementation
415 
416 uses
417  ZMessages, DateUtils;
418 
419 Function IncDate(const aDate : TDateTime; const aYear, aMonth, aWeek, aDay : LongInt) : TDateTime;
420 begin
421  Result := aDate;
422  if aYear <> 0 then Result := IncYear(Result, aYear);
423  if aMonth <> 0 then Result := IncMonth(Result, aMonth);
424  if aWeek <> 0 then Result := IncWeek(Result, aWeek);
425  if aDay <> 0 then Result := IncDay(Result, aDay);
426 end;
427 
428 Function IncTime(const aDate : TDateTime; const aHour, aMinute, aSecond, aMillisec : LongInt) : TDateTime;
429 begin
430  Result := IncHour(IncMinute(IncSecond(IncMillisecond(aDate, aMilliSec),aSecond),aMinute),aHour);
431 end;
432 
433 { TZDateFunction }
434 
435 function TZDateFunction.Execute(Stack: TZExecutionStack;
436  VariantManager: IZVariantManager): TZVariant;
437 begin
438  CheckParamsCount(Stack, 0);
439  VariantManager.SetAsDateTime(Result, Date);
440 end;
441 
442 { TZTimeFunction }
443 
444 {**
445  Executes this function.
446  @param Stack the stack object.
447  @param VariantManager a reference to variant processor object.
448  @returns a function value.
449 }
450 function TZTimeFunction.Execute(Stack: TZExecutionStack;
451  VariantManager: IZVariantManager): TZVariant;
452 begin
453  CheckParamsCount(Stack, 0);
454  VariantManager.SetAsDateTime(Result, Time);
455 end;
456 
457 { TZNowFunction }
458 
459 function TZNowFunction.Execute(Stack: TZExecutionStack;
460  VariantManager: IZVariantManager): TZVariant;
461 begin
462  CheckParamsCount(Stack, 0);
463  VariantManager.SetAsDateTime(Result, Now);
464 end;
465 
466 { TZEncodeDateFunction }
467 
468 function TZEncodeDateFunction.Execute(Stack: TZExecutionStack;
469  VariantManager: IZVariantManager): TZVariant;
470 var
471  ParamsCount: Integer;
472  Year , Month, Day : LongInt;
473 begin
474  ParamsCount := VariantManager.GetAsInteger(Stack.GetParameter(0));
475 
476  Year := 0;
477  Month := 1;
478  Day := 1;
479 
480  if ParamsCount > 0 then
481  Year := VariantManager.GetAsInteger(Stack.GetParameter(ParamsCount));
482  if ParamsCount > 1 then
483  Month := VariantManager.GetAsInteger(Stack.GetParameter(ParamsCount-1));
484  if ParamsCount > 2 then
485  Day := VariantManager.GetAsInteger(Stack.GetParameter(ParamsCount-2));
486 
487  VariantManager.SetAsDateTime(Result, EncodeDate(Year,Month,Day));
488 end;
489 
490 { TZEncodeDateFunction }
491 
492 function TZEncodeTimeFunction.Execute(Stack: TZExecutionStack;
493  VariantManager: IZVariantManager): TZVariant;
494 var
495  ParamsCount: Integer;
496  Hour , Minute, Second, MilliSecond : LongInt;
497 begin
498  ParamsCount := VariantManager.GetAsInteger(Stack.GetParameter(0));
499 
500  Hour := 0;
501  Minute := 0;
502  Second := 0;
503  MilliSecond := 0;
504 
505  if ParamsCount > 0 then
506  Hour := VariantManager.GetAsInteger(Stack.GetParameter(ParamsCount));
507  if ParamsCount > 1 then
508  Minute := VariantManager.GetAsInteger(Stack.GetParameter(ParamsCount-1));
509  if ParamsCount > 2 then
510  Second := VariantManager.GetAsInteger(Stack.GetParameter(ParamsCount-2));
511  if ParamsCount > 3 then
512  MilliSecond := VariantManager.GetAsInteger(Stack.GetParameter(ParamsCount-3));
513 
514  VariantManager.SetAsDateTime(Result, EncodeTime(Hour,Minute,Second,MilliSecond));
515 end;
516 
517 { TZComposeDateTimeFunction }
518 
519 function TZComposeDateTimeFunction.Execute(Stack: TZExecutionStack;
520  VariantManager: IZVariantManager): TZVariant;
521 begin
522  CheckParamsCount(Stack, 2);
523  VariantManager.SetAsDateTime(Result, VariantManager.GetAsDateTime(Stack.GetParameter(2))+
524  VariantManager.GetAsDateTime(Stack.GetParameter(1)));
525 end;
526 
527 { TZIncDateFunction }
528 
529 function TZIncDateFunction.Execute(Stack: TZExecutionStack;
530  VariantManager: IZVariantManager): TZVariant;
531 var
532  ParamsCount: Integer;
533  Date : TDateTime;
534  Year , Month, Week, Day : LongInt;
535 begin
536  ParamsCount := VariantManager.GetAsInteger(Stack.GetParameter(0));
537 
538  if (ParamsCount <= 2) then
539  raise TZExpressionError.Create(SExpectedMoreParams);
540 
541  Date := VariantManager.GetAsDateTime(Stack.GetParameter(ParamsCount));
542  Year := VariantManager.GetAsInteger(Stack.GetParameter(ParamsCount-1));
543  Month := 0;
544  Week := 0;
545  Day := 0;
546  if ParamsCount > 2 then
547  Month := VariantManager.GetAsInteger(Stack.GetParameter(ParamsCount-2));
548  if ParamsCount > 3 then
549  Week := VariantManager.GetAsInteger(Stack.GetParameter(ParamsCount-3));
550  if ParamsCount > 4 then
551  Day := VariantManager.GetAsInteger(Stack.GetParameter(ParamsCount-4));
552 
553  VariantManager.SetAsDateTime(Result, IncDate(Date,Year,Month,Week,Day));
554 end;
555 
556 { TZIncTimeFunction }
557 
558 function TZIncTimeFunction.Execute(Stack: TZExecutionStack;
559  VariantManager: IZVariantManager): TZVariant;
560 var
561  ParamsCount: Integer;
562  Date : TDateTime;
563  Hour , Minute, Second, MilliSecond : LongInt;
564 begin
565  ParamsCount := VariantManager.GetAsInteger(Stack.GetParameter(0));
566 
567  if (ParamsCount <= 2) then
568  raise TZExpressionError.Create(SExpectedMoreParams);
569 
570  Date := VariantManager.GetAsDateTime(Stack.GetParameter(ParamsCount));
571  Hour := VariantManager.GetAsInteger(Stack.GetParameter(ParamsCount-1));
572 
573  Minute := 0;
574  Second := 0;
575  MilliSecond := 0;
576 
577  if ParamsCount > 2 then
578  Minute := VariantManager.GetAsInteger(Stack.GetParameter(ParamsCount-2));
579  if ParamsCount > 3 then
580  Second := VariantManager.GetAsInteger(Stack.GetParameter(ParamsCount-3));
581  if ParamsCount > 4 then
582  MilliSecond := VariantManager.GetAsInteger(Stack.GetParameter(ParamsCount-4));
583 
584  VariantManager.SetAsDateTime(Result, IncTime(Date, Hour,Minute,Second,MilliSecond));
585 end;
586 
587 { TZIsLeapYearFunction }
588 
589 function TZIsLeapYearFunction.Execute(Stack: TZExecutionStack;
590  VariantManager: IZVariantManager): TZVariant;
591 begin
592  CheckParamsCount(Stack, 1);
593  VariantManager.SetAsBoolean(Result, IsLeapYear(
594  VariantManager.GetAsInteger(Stack.GetParameter(1))));
595 end;
596 
597 { TZDateOfFunction }
598 
599 function TZDateOfFunction.Execute(Stack: TZExecutionStack;
600  VariantManager: IZVariantManager): TZVariant;
601 begin
602  CheckParamsCount(Stack, 1);
603  VariantManager.SetAsDateTime(Result, DateOf(
604  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
605 end;
606 
607 { TZTimeOfFunction }
608 
609 function TZTimeOfFunction.Execute(Stack: TZExecutionStack;
610  VariantManager: IZVariantManager): TZVariant;
611 begin
612  CheckParamsCount(Stack, 1);
613  VariantManager.SetAsDateTime(Result, TimeOf(
614  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
615 end;
616 
617 { TZYearOfFunction }
618 
619 function TZYearOfFunction.Execute(Stack: TZExecutionStack;
620  VariantManager: IZVariantManager): TZVariant;
621 begin
622  CheckParamsCount(Stack, 1);
623  VariantManager.SetAsInteger(Result, YearOf(
624  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
625 end;
626 
627 { TZMonthOfFunction }
628 
629 function TZMonthOfFunction.Execute(Stack: TZExecutionStack;
630  VariantManager: IZVariantManager): TZVariant;
631 begin
632  CheckParamsCount(Stack, 1);
633  VariantManager.SetAsInteger(Result, MonthOf(
634  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
635 end;
636 
637 { TZDayOfFunction }
638 
639 function TZDayOfFunction.Execute(Stack: TZExecutionStack;
640  VariantManager: IZVariantManager): TZVariant;
641 begin
642  CheckParamsCount(Stack, 1);
643  VariantManager.SetAsInteger(Result, DayOf(
644  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
645 end;
646 
647 { TZHourOfFunction }
648 
649 function TZHourOfFunction.Execute(Stack: TZExecutionStack;
650  VariantManager: IZVariantManager): TZVariant;
651 begin
652  CheckParamsCount(Stack, 1);
653  VariantManager.SetAsInteger(Result, HourOf(
654  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
655 end;
656 
657 { TZMinuteOfFunction }
658 
659 function TZMinuteOfFunction.Execute(Stack: TZExecutionStack;
660  VariantManager: IZVariantManager): TZVariant;
661 begin
662  CheckParamsCount(Stack, 1);
663  VariantManager.SetAsInteger(Result, MinuteOf(
664  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
665 end;
666 
667 { TZSecondOfFunction }
668 
669 function TZSecondOfFunction.Execute(Stack: TZExecutionStack;
670  VariantManager: IZVariantManager): TZVariant;
671 begin
672  CheckParamsCount(Stack, 1);
673  VariantManager.SetAsInteger(Result, SecondOf(
674  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
675 end;
676 
677 { TZMilliSecondOfFunction }
678 
679 function TZMilliSecondOfFunction.Execute(Stack: TZExecutionStack;
680  VariantManager: IZVariantManager): TZVariant;
681 begin
682  CheckParamsCount(Stack, 1);
683  VariantManager.SetAsInteger(Result, MilliSecondOf(
684  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
685 end;
686 
687 { TZWeekOfTheYearFunction }
688 
689 function TZWeekOfTheYearFunction.Execute(Stack: TZExecutionStack;
690  VariantManager: IZVariantManager): TZVariant;
691 begin
692  CheckParamsCount(Stack, 1);
693  VariantManager.SetAsInteger(Result, WeekOfTheYear(
694  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
695 end;
696 
697 { TZDayOfTheYearFunction }
698 
699 function TZDayOfTheYearFunction.Execute(Stack: TZExecutionStack;
700  VariantManager: IZVariantManager): TZVariant;
701 begin
702  CheckParamsCount(Stack, 1);
703  VariantManager.SetAsInteger(Result, DayOfTheYear(
704  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
705 end;
706 
707 { TZHourOfTheYearFunction }
708 
709 function TZHourOfTheYearFunction.Execute(Stack: TZExecutionStack;
710  VariantManager: IZVariantManager): TZVariant;
711 begin
712  CheckParamsCount(Stack, 1);
713  VariantManager.SetAsInteger(Result, HourOfTheYear(
714  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
715 end;
716 
717 { TZMinuteOfTheYearFunction }
718 
719 function TZMinuteOfTheYearFunction.Execute(Stack: TZExecutionStack;
720  VariantManager: IZVariantManager): TZVariant;
721 begin
722  CheckParamsCount(Stack, 1);
723  VariantManager.SetAsInteger(Result, MinuteOfTheYear(
724  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
725 end;
726 
727 { TZSecondOfTheYearFunction }
728 
729 function TZSecondOfTheYearFunction.Execute(Stack: TZExecutionStack;
730  VariantManager: IZVariantManager): TZVariant;
731 begin
732  CheckParamsCount(Stack, 1);
733  VariantManager.SetAsInteger(Result, SecondOfTheYear(
734  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
735 end;
736 
737 { TZMilliSecondOfTheYearFunction }
738 
739 function TZMilliSecondOfTheYearFunction.Execute(Stack: TZExecutionStack;
740  VariantManager: IZVariantManager): TZVariant;
741  {$IFDEF WITH_MILLISECONDOFTHEYEAR_BUG}
742  function MilliSecondOfTheYear(const AValue: TDateTime): Int64;
743  begin
744  Result := MilliSecondOf(AValue) + Int64(SecondOfTheYear(AValue)) * MSecsPerSec;
745  end;
746  {$ENDIF}
747 begin
748  CheckParamsCount(Stack, 1);
749  VariantManager.SetAsInteger(Result, MilliSecondOfTheYear(
750  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
751 end;
752 
753 { TZWeekOfTheMonthFunction }
754 
755 function TZWeekOfTheMonthFunction.Execute(Stack: TZExecutionStack;
756  VariantManager: IZVariantManager): TZVariant;
757 begin
758  CheckParamsCount(Stack, 1);
759  VariantManager.SetAsInteger(Result, WeekOfTheMonth(
760  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
761 end;
762 
763 { TZHourOfTheMonthFunction }
764 
765 function TZHourOfTheMonthFunction.Execute(Stack: TZExecutionStack;
766  VariantManager: IZVariantManager): TZVariant;
767 begin
768  CheckParamsCount(Stack, 1);
769  VariantManager.SetAsInteger(Result, HourOfTheMonth(
770  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
771 end;
772 
773 { TZMinuteOfTheMonthFunction }
774 
775 function TZMinuteOfTheMonthFunction.Execute(Stack: TZExecutionStack;
776  VariantManager: IZVariantManager): TZVariant;
777 begin
778  CheckParamsCount(Stack, 1);
779  VariantManager.SetAsInteger(Result, MinuteOfTheMonth(
780  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
781 end;
782 
783 { TZSecondOfTheMonthFunction }
784 
785 function TZSecondOfTheMonthFunction.Execute(Stack: TZExecutionStack;
786  VariantManager: IZVariantManager): TZVariant;
787 begin
788  CheckParamsCount(Stack, 1);
789  VariantManager.SetAsInteger(Result, SecondOfTheMonth(
790  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
791 end;
792 
793 { TZMilliSecondOfTheMonthFunction }
794 
795 function TZMilliSecondOfTheMonthFunction.Execute(Stack: TZExecutionStack;
796  VariantManager: IZVariantManager): TZVariant;
797 begin
798  CheckParamsCount(Stack, 1);
799  VariantManager.SetAsInteger(Result, MilliSecondOfTheMonth(
800  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
801 end;
802 
803 { TZDayOfTheWeekFunction }
804 
805 function TZDayOfTheWeekFunction.Execute(Stack: TZExecutionStack;
806  VariantManager: IZVariantManager): TZVariant;
807 begin
808  CheckParamsCount(Stack, 1);
809  VariantManager.SetAsInteger(Result, DayOfTheWeek(
810  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
811 end;
812 
813 { TZHourOfTheWeekFunction }
814 
815 function TZHourOfTheWeekFunction.Execute(Stack: TZExecutionStack;
816  VariantManager: IZVariantManager): TZVariant;
817 begin
818  CheckParamsCount(Stack, 1);
819  VariantManager.SetAsInteger(Result, HourOfTheWeek(
820  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
821 end;
822 
823 { TZMinuteOfTheWeekFunction }
824 
825 function TZMinuteOfTheWeekFunction.Execute(Stack: TZExecutionStack;
826  VariantManager: IZVariantManager): TZVariant;
827 begin
828  CheckParamsCount(Stack, 1);
829  VariantManager.SetAsInteger(Result, MinuteOfTheWeek(
830  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
831 end;
832 
833 { TZSecondOfTheWeekFunction }
834 
835 function TZSecondOfTheWeekFunction.Execute(Stack: TZExecutionStack;
836  VariantManager: IZVariantManager): TZVariant;
837 begin
838  CheckParamsCount(Stack, 1);
839  VariantManager.SetAsInteger(Result, SecondOfTheWeek(
840  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
841 end;
842 
843 { TZMilliSecondOfTheWeekFunction }
844 
845 function TZMilliSecondOfTheWeekFunction.Execute(Stack: TZExecutionStack;
846  VariantManager: IZVariantManager): TZVariant;
847 begin
848  CheckParamsCount(Stack, 1);
849  VariantManager.SetAsInteger(Result, MilliSecondOfTheWeek(
850  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
851 end;
852 
853 { TZMinuteOfTheDayFunction }
854 
855 function TZMinuteOfTheDayFunction.Execute(Stack: TZExecutionStack;
856  VariantManager: IZVariantManager): TZVariant;
857 begin
858  CheckParamsCount(Stack, 1);
859  VariantManager.SetAsInteger(Result, MinuteOfTheDay(
860  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
861 end;
862 
863 { TZSecondOfTheDayFunction }
864 
865 function TZSecondOfTheDayFunction.Execute(Stack: TZExecutionStack;
866  VariantManager: IZVariantManager): TZVariant;
867 begin
868  CheckParamsCount(Stack, 1);
869  VariantManager.SetAsInteger(Result, SecondOfTheDay(
870  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
871 end;
872 
873 { TZMilliSecondOfTheDayFunction }
874 
875 function TZMilliSecondOfTheDayFunction.Execute(Stack: TZExecutionStack;
876  VariantManager: IZVariantManager): TZVariant;
877 begin
878  CheckParamsCount(Stack, 1);
879  VariantManager.SetAsInteger(Result, MilliSecondOfTheDay(
880  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
881 end;
882 
883 { TZSecondOfTheHourFunction }
884 
885 function TZSecondOfTheHourFunction.Execute(Stack: TZExecutionStack;
886  VariantManager: IZVariantManager): TZVariant;
887 begin
888  CheckParamsCount(Stack, 1);
889  VariantManager.SetAsInteger(Result, SecondOfTheHour(
890  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
891 end;
892 
893 { TZMilliSecondOfTheHourFunction }
894 
895 function TZMilliSecondOfTheHourFunction.Execute(Stack: TZExecutionStack;
896  VariantManager: IZVariantManager): TZVariant;
897 begin
898  CheckParamsCount(Stack, 1);
899  VariantManager.SetAsInteger(Result, MilliSecondOfTheHour(
900  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
901 end;
902 
903 { TZMilliSecondOfTheMinuteFunction }
904 
905 function TZMilliSecondOfTheMinuteFunction.Execute(Stack: TZExecutionStack;
906  VariantManager: IZVariantManager): TZVariant;
907 begin
908  CheckParamsCount(Stack, 1);
909  VariantManager.SetAsInteger(Result, MilliSecondOfTheMinute(
910  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
911 end;
912 
913 { TZYearsBetweenFunction }
914 
915 function TZYearsBetweenFunction.Execute(Stack: TZExecutionStack;
916  VariantManager: IZVariantManager): TZVariant;
917 begin
918  CheckParamsCount(Stack, 2);
919  VariantManager.SetAsInteger(Result, YearsBetween(
920  VariantManager.GetAsDateTime(Stack.GetParameter(2)),
921  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
922 end;
923 
924 { TZMonthsBetweenFunction }
925 
926 function TZMonthsBetweenFunction.Execute(Stack: TZExecutionStack;
927  VariantManager: IZVariantManager): TZVariant;
928 begin
929  CheckParamsCount(Stack, 2);
930  VariantManager.SetAsInteger(Result, MonthsBetween(
931  VariantManager.GetAsDateTime(Stack.GetParameter(2)),
932  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
933 end;
934 
935 { TZWeeksBetweenFunction }
936 
937 function TZWeeksBetweenFunction.Execute(Stack: TZExecutionStack;
938  VariantManager: IZVariantManager): TZVariant;
939 begin
940  CheckParamsCount(Stack, 2);
941  VariantManager.SetAsInteger(Result, WeeksBetween(
942  VariantManager.GetAsDateTime(Stack.GetParameter(2)),
943  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
944 end;
945 
946 { TZDaysBetweenFunction }
947 
948 function TZDaysBetweenFunction.Execute(Stack: TZExecutionStack;
949  VariantManager: IZVariantManager): TZVariant;
950 begin
951  CheckParamsCount(Stack, 2);
952  VariantManager.SetAsInteger(Result, DaysBetween(
953  VariantManager.GetAsDateTime(Stack.GetParameter(2)),
954  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
955 end;
956 
957 { TZHoursBetweenFunction }
958 
959 function TZHoursBetweenFunction.Execute(Stack: TZExecutionStack;
960  VariantManager: IZVariantManager): TZVariant;
961 begin
962  CheckParamsCount(Stack, 2);
963  VariantManager.SetAsInteger(Result, HoursBetween(
964  VariantManager.GetAsDateTime(Stack.GetParameter(2)),
965  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
966 end;
967 
968 { TZMinutesBetweenFunction }
969 
970 function TZMinutesBetweenFunction.Execute(Stack: TZExecutionStack;
971  VariantManager: IZVariantManager): TZVariant;
972 begin
973  CheckParamsCount(Stack, 2);
974  VariantManager.SetAsInteger(Result, MinutesBetween(
975  VariantManager.GetAsDateTime(Stack.GetParameter(2)),
976  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
977 end;
978 
979 { TZSecondsBetweenFunction }
980 
981 function TZSecondsBetweenFunction.Execute(Stack: TZExecutionStack;
982  VariantManager: IZVariantManager): TZVariant;
983 begin
984  CheckParamsCount(Stack, 2);
985  VariantManager.SetAsInteger(Result, SecondsBetween(
986  VariantManager.GetAsDateTime(Stack.GetParameter(2)),
987  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
988 end;
989 
990 { TZHoursBetweenFunction }
991 
992 function TZMillisecondsBetweenFunction.Execute(Stack: TZExecutionStack;
993  VariantManager: IZVariantManager): TZVariant;
994 begin
995  CheckParamsCount(Stack, 2);
996  VariantManager.SetAsInteger(Result, MillisecondsBetween(
997  VariantManager.GetAsDateTime(Stack.GetParameter(2)),
998  VariantManager.GetAsDateTime(Stack.GetParameter(1))));
999 end;
1000 
1001 procedure AddDateTimeFunctions(Functions : TZFunctionsList);
1002 begin
1003  Functions.Add(TZDateFunction.Create('DATE'));
1004  Functions.Add(TZTimeFunction.Create('TIME'));
1005  Functions.Add(TZNowFunction.Create('NOW'));
1006 
1007 // First the Aliases
1008 
1009  Functions.Add(TZEncodeDateFunction.Create('ENCD'));
1010  Functions.Add(TZEncodeTimeFunction.Create('ENCT'));
1011 // Functions.Add(TZComposeDateTimeFunction.Create('COMPDT'));
1012 
1013  Functions.Add(TZIncDateFunction.Create('INCD'));
1014  Functions.Add(TZIncTimeFunction.Create('INCT'));
1015 
1016  Functions.Add(TZIsLeapYearFunction.Create('LEAPY'));
1017 
1018 // Functions.Add(TZDateOfFunction.Create('DATEOF'));
1019 // Functions.Add(TZTimeOfFunction.Create('TIMEOF'));
1020 
1021 // Functions.Add(TZYearOfFunction.Create('YEAROF'));
1022 // Functions.Add(TZMonthOfFunction.Create('MONTHOF'));
1023 // Functions.Add(TZDayOfFunction.Create('DAYOF'));
1024 // Functions.Add(TZHourOfFunction.Create('HOUROF'));
1025 
1026  Functions.Add(TZMinuteOfFunction.Create('MINOF'));
1027  Functions.Add(TZSecondOfFunction.Create('SECOF'));
1028  Functions.Add(TZMilliSecondOfFunction.Create('MSECOF'));
1029 
1030  Functions.Add(TZWeekOfTheYearFunction.Create('WofY'));
1031  Functions.Add(TZDayOfTheYearFunction.Create('DofY'));
1032  Functions.Add(TZHourOfTheYearFunction.Create('HofY'));
1033  Functions.Add(TZMinuteOfTheYearFunction.Create('MINofY'));
1034  Functions.Add(TZSecondOfTheYearFunction.Create('SECofY'));
1035  Functions.Add(TZMilliSecondOfTheYearFunction.Create('MSECofY'));
1036 
1037  Functions.Add(TZWeekOfTheMonthFunction.Create('WofM'));
1038  Functions.Add(TZHourOfTheMonthFunction.Create('HofM'));
1039  Functions.Add(TZMinuteOfTheMonthFunction.Create('MINofM'));
1040  Functions.Add(TZSecondOfTheMonthFunction.Create('SECofM'));
1041  Functions.Add(TZMilliSecondOfTheMonthFunction.Create('MSECofM'));
1042 
1043  Functions.Add(TZDayOfTheWeekFunction.Create('DofW'));
1044  Functions.Add(TZHourOfTheWeekFunction.Create('HofW'));
1045  Functions.Add(TZMinuteOfTheWeekFunction.Create('MINofW'));
1046  Functions.Add(TZSecondOfTheWeekFunction.Create('SECofW'));
1047  Functions.Add(TZMilliSecondOfTheWeekFunction.Create('MSECofW'));
1048 
1049  Functions.Add(TZMinuteOfTheDayFunction.Create('MINofD'));
1050  Functions.Add(TZSecondOfTheDayFunction.Create('SECofD'));
1051  Functions.Add(TZMilliSecondOfTheDayFunction.Create('MSECofD'));
1052 
1053  Functions.Add(TZSecondOfTheHourFunction.Create('SECofH'));
1054  Functions.Add(TZMilliSecondOfTheHourFunction.Create('MSECofH'));
1055 
1056  Functions.Add(TZMilliSecondOfTheMinuteFunction.Create('MSECofMIN'));
1057 
1058  Functions.Add(TZYearsBetweenFunction.Create('YBTW'));
1059  Functions.Add(TZMonthsBetweenFunction.Create('MBTW'));
1060  Functions.Add(TZWeeksBetweenFunction.Create('WBTW'));
1061  Functions.Add(TZDaysBetweenFunction.Create('DBTW'));
1062  Functions.Add(TZHoursBetweenFunction.Create('HBTW'));
1063  Functions.Add(TZMinutesBetweenFunction.Create('MINBTW'));
1064  Functions.Add(TZSecondsBetweenFunction.Create('SECBTW'));
1065  Functions.Add(TZMilliSecondsBetweenFunction.Create('MSECBTW'));
1066 
1067 // End of Aliases
1068 
1069  Functions.Add(TZEncodeDateFunction.Create('ENCODEDATE'));
1070  Functions.Add(TZEncodeTimeFunction.Create('ENCODETIME'));
1071  Functions.Add(TZComposeDateTimeFunction.Create('COMPOSEDATETIME'));
1072 
1073  Functions.Add(TZIncDateFunction.Create('INCDATE'));
1074  Functions.Add(TZIncTimeFunction.Create('INCTIME'));
1075 
1076  Functions.Add(TZIsLeapYearFunction.Create('ISLEAPYEAR'));
1077 
1078  Functions.Add(TZDateOfFunction.Create('DATEOF'));
1079  Functions.Add(TZTimeOfFunction.Create('TIMEOF'));
1080 
1081  Functions.Add(TZYearOfFunction.Create('YEAROF'));
1082  Functions.Add(TZMonthOfFunction.Create('MONTHOF'));
1083  Functions.Add(TZDayOfFunction.Create('DAYOF'));
1084  Functions.Add(TZHourOfFunction.Create('HOUROF'));
1085 
1086  Functions.Add(TZMinuteOfFunction.Create('MINUTEOF'));
1087  Functions.Add(TZSecondOfFunction.Create('SECONDOF'));
1088  Functions.Add(TZMilliSecondOfFunction.Create('MILLISECONDOF'));
1089 
1090  Functions.Add(TZWeekOfTheYearFunction.Create('WEEKOFTHEYEAR'));
1091  Functions.Add(TZDayOfTheYearFunction.Create('DAYOFTHEYEAR'));
1092  Functions.Add(TZHourOfTheYearFunction.Create('HOUROFTHEYEAR'));
1093  Functions.Add(TZMinuteOfTheYearFunction.Create('MINUTEOFTHEYEAR'));
1094  Functions.Add(TZSecondOfTheYearFunction.Create('SECONDOFTHEYEAR'));
1095  Functions.Add(TZMilliSecondOfTheYearFunction.Create('MILLISECONDOFTHEYEAR'));
1096 
1097  Functions.Add(TZWeekOfTheMonthFunction.Create('WEEKOFTHEMONTH'));
1098  Functions.Add(TZHourOfTheMonthFunction.Create('HOUROFTHEMONTH'));
1099  Functions.Add(TZMinuteOfTheMonthFunction.Create('MINUTEOFTHEMONTH'));
1100  Functions.Add(TZSecondOfTheMonthFunction.Create('SECONDOFTHEMONTH'));
1101  Functions.Add(TZMilliSecondOfTheMonthFunction.Create('MILLISECONDOFTHEMONTH'));
1102 
1103  Functions.Add(TZDayOfTheWeekFunction.Create('DAYOFTHEWEEK'));
1104  Functions.Add(TZHourOfTheWeekFunction.Create('HOUROFTHEWEEK'));
1105  Functions.Add(TZMinuteOfTheWeekFunction.Create('MINUTEOFTHEWEEK'));
1106  Functions.Add(TZSecondOfTheWeekFunction.Create('SECONDOFTHEWEEK'));
1107  Functions.Add(TZMilliSecondOfTheWeekFunction.Create('MILLISECONDOFTHEWEEK'));
1108 
1109  Functions.Add(TZMinuteOfTheDayFunction.Create('MINUTEOFTHEDAY'));
1110  Functions.Add(TZSecondOfTheDayFunction.Create('SECONDOFTHEDAY'));
1111  Functions.Add(TZMilliSecondOfTheDayFunction.Create('MILLISECONDOFTHEDAY'));
1112 
1113  Functions.Add(TZSecondOfTheHourFunction.Create('SECONDOFTHEHOUR'));
1114  Functions.Add(TZMilliSecondOfTheHourFunction.Create('MILLISECONDOFTHEHOUR'));
1115 
1116  Functions.Add(TZMilliSecondOfTheMinuteFunction.Create('MILLISECONDOFTHEMINUTE'));
1117 
1118  Functions.Add(TZYearsBetweenFunction.Create('YEARSBETWEEN'));
1119  Functions.Add(TZMonthsBetweenFunction.Create('MONTHSBETWEEN'));
1120  Functions.Add(TZWeeksBetweenFunction.Create('WEEKSBETWEEN'));
1121  Functions.Add(TZDaysBetweenFunction.Create('DAYSBETWEEN'));
1122  Functions.Add(TZHoursBetweenFunction.Create('HOURSBETWEEN'));
1123  Functions.Add(TZMinutesBetweenFunction.Create('MINUTESBETWEEN'));
1124  Functions.Add(TZSecondsBetweenFunction.Create('SECONDSBETWEEN'));
1125  Functions.Add(TZMilliSecondsBetweenFunction.Create('MILLISECONDSBETWEEN'));
1126 
1127 end;
1128 
1129 end.