along/secondo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
dfd1e745480fabd88139d2804acb90d5b6dc055e
secondo/Algebras/Date/DateAlgebra.cpp

1176 lines
30 KiB
C++
Raw Normal View History

firs commit
2026-01-23 17:03:45 +08:00
/*
----
This file is part of SECONDO.
Copyright (C) 2004, University in Hagen, Department of Computer Science,
Database Systems for New Applications.
SECONDO is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
SECONDO is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with SECONDO; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
----
//paragraph [1] Title: [{\Large \bf \begin{center}] [\end{center}}]
//paragraph [10] Footnote: [{\footnote{] [}}]
//[->] [$\rightarrow$]
//[TOC] [\tableofcontents]
//[_] [\_]
[1] Implementation of the Date Algebra
December 11-26, 2002 Zhiming Ding
December 2005, Victor Almeida deleted the deprecated algebra levels
(~executable~, ~descriptive~, and ~hibrid~). Only the executable
level remains. Models are also removed from type constructors.
[TOC]
1 Preliminaries
This algebra provides one type constructor ~date~, and seven operators:
\verb+<+ , = , \verb+>+, ~year[_]of~, ~month[_]of~, ~day[_]of~, and ~thedate~.
Signatures of these operators are listed below:
* \verb+<+ , = , \verb+>+
---- date x date -> bool
----
compare two dates.
* year[_]of, month[_]of, day[_]of
---- date -> int
----
extract year, month, day information from a date.
* thedate
---- int x int x int -> date
----
generates a date according to the specified year, month,
and day information
The algebra provides basic checks on the validity of a date.
For instance, Fabruary in leap years
(every 4 years except 100th year, and every 400th year) has
29 days, and Fabruary in normal years only
has 28 days.
1.1 Includes
*/
#include "Attribute.h"
#include "Algebra.h"
#include "NestedList.h"
#include "QueryProcessor.h"
#include "AlgebraManager.h"
#include "StandardTypes.h"
#include "StringUtils.h"
#include "ListUtils.h"
#include <iostream>
#include <string>
#include <stdio.h>
using namespace std;
extern NestedList* nl;
extern QueryProcessor *qp;
extern AlgebraManager *am;
/*
1.2 Date Validating Function
This function checks whether an input date is valid. The month
and the day must be within valid
boundaries. However, the year can be any integer. For instance, -100 represents
the year of 100BC.
*/
bool isdate(int Day, int Month, int Year)
{
bool res=true;
bool leapyear=false;
int daysinmonth=0;
if (((Year % 4==0) && (Year % 100!=0)) || (Year % 400==0))
leapyear=true; else leapyear=false;
if ((Month<1)||(Month>12)) res=false;
else
{
switch (Month)
{
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12: daysinmonth=31; break;
case 4:
case 6:
case 9:
case 11: daysinmonth=30; break;
case 2: if (leapyear) daysinmonth=29; else daysinmonth=28;
}
if ((Day<1)||(Day>daysinmonth)) res=false;
}
return res;
}
/*
2 Type Constructor ~date~
2.1 Data Structure - Class ~Date~
In order to use ~date~ as an attribute type in tuple definitions,
we must derive the class ~Date~ from ~Attribute~.
*/
class Date: public Attribute
{
public:
Date(bool Defined, int Day, int Month, int Year);
Date();
~Date();
int GetDay() const;
int GetMonth() const;
int GetYear() const;
void SetDay( int Day);
void SetMonth( int Yonth);
void SetYear( int Year);
void Set(bool Defined, int Day, int Month, int Year);
/*
~readFrom~
Sets this date value to the given string. accepted formats are
yyy-mm-dd and dd.mm.yyyy where leading zeros can be ommitted.
If the string does not represent a valid day, this Date value
remains unchanged and false is returned.
*/
bool readFrom(string& d);
/*
~ReadFromString~
works similar to the readFrom function. In contrast to that function,
this Date is set to be false in the string does not represent a
valid date.
*/
virtual void ReadFromString(string d);
/*
getCsvStr
Returns a string represnetation of this date value.
*/
virtual string getCsvStr() const;
void successor(const Date *d, Date *s) const;
/*************************************************************************
The following 8 virtual functions: IsDefined(), SetDefined(), HashValue(),
CopyFrom(), Compare(), Adjacent(), Clone(), Print(), need to be defined if
we want to use ~date~ as an attribute type in tuple definitions.
*************************************************************************/
bool IsDefined() const;
void SetDefined(bool Defined);
size_t Sizeof() const;
size_t HashValue() const;
void CopyFrom(const Attribute* right);
int Compare(const Attribute * arg) const;
bool Adjacent(const Attribute * arg) const;
Date* Clone() const;
ostream& Print( ostream &os ) const;
static const string BasicType(){
return "date";
}
static const bool checkType(const ListExpr list){
return listutils::isSymbol(list, BasicType());
}
private:
int day;
int month;
int year;
bool defined;
};
Date::Date(bool Defined, int Day, int Month, int Year)
{
defined = Defined;
day = Day;
month = Month;
year = Year;
}
Date::Date() {}
Date::~Date() {}
int Date::GetDay() const {return day;}
int Date::GetMonth() const {return month;}
int Date::GetYear() const {return year;}
void Date::SetDay(int Day) {day = Day;}
void Date::SetMonth(int Month) {month = Month;}
void Date::SetYear(int Year) {year = Year;}
void Date::Set(bool Defined, int Day, int Month, int Year)
{
defined = Defined;
day = Day;
month = Month;
year = Year;
}
bool Date::readFrom(string& s){
stringutils::trim(s);
if(s.length()>99){
return false;
}
char *i, *j;
int dot = 0;
int hyphen = 0;
int Year;
int Month;
int Day;
char buf[100];
const char* c_string = s.c_str();
if ( (strcmp(c_string,"-")==0) ) // undefined, special notation
{
Set(false, 0,0,0);
return true;
}
//"1998-02-01" or "1999-2-1" or "1.2.1998" or "02.01.1999"
strcpy(buf, c_string);
int bufLen=strlen(buf);
//basic check on date format
for ( i=buf; i<buf+bufLen; i++) {
if (*i=='.') dot++;
if (*i=='-') hyphen++;
if ((*i!='.') && (*i!='-') && ((*i<'0') || (*i>'9'))) {
// invalid character
return false;
}
}
if ((hyphen == 2) && (dot == 0)) //format is "1998-02-01"
{
//extract the year, month, day information from the date
i=buf; j=i;
while ((*j!='-') && (j<buf+bufLen)) j++;
*j=0;
Year=atoi(i);
i=j+1; j=i;
while ((*j!='-') && (j<buf+bufLen)) j++;
*j=0;
Month=atoi(i);
i=j+1; j=i;
while ((*j!='-') && (j<buf+bufLen)) j++;
*j=0;
Day=atoi(i);
} else if ((hyphen == 0) && (dot == 2)) { //format is "1.2.1998"
//extract the year, month, day information from the date
i=buf; j=i;
while ((*j!='.') && (j<buf+bufLen)) j++;
*j=0;
Day=atoi(i);
i=j+1; j=i;
while ((*j!='.') && (j<buf+bufLen)) j++;
*j=0;
Month=atoi(i);
i=j+1; j=i;
while ((*j!='.') && (j<buf+bufLen)) j++;
*j=0;
Year=atoi(i);
} else {
return false;
}
if (isdate(Day, Month, Year)) {
Set(true, Day, Month, Year);
return true;
} else {
return false;
}
}
void Date::ReadFromString(string s){
if(!readFrom(s)){
SetDefined(false);
}
}
string Date::getCsvStr() const{
stringstream ss;
Print(ss);
return ss.str();
}
/*************************************************************************
In the following, we give the definitions of the 9 virtual functions
which are needed
if we want to use ~date~ as an attribute type in tuple definitions.
*************************************************************************/
bool Date::IsDefined() const {return (defined); }
void Date::SetDefined(bool Defined) {defined = Defined; }
size_t Date::Sizeof() const
{
return sizeof( *this );
}
size_t Date::HashValue() const
{
if(!defined) return (0);
unsigned long h;
h=5*(5*day+month)+year;
return size_t(h);
}
void Date::CopyFrom(const Attribute* right)
{
const Date * d = (const Date*)right;
defined = d->defined;
day = d->day;
month = d->month;
year = d->year;
}
/*
The function Compare() defines a total order on the data type ~date~.
*/
int Date::Compare(const Attribute * arg) const
{
int res=0;
const Date * d = (const Date* )(arg);
if ( !d ) return (-2);
if (!IsDefined() && !(arg->IsDefined())) res=0;
else if (!IsDefined()) res=-1;
else if (!(arg->IsDefined())) res=1;
else
{
if ((this->GetYear()) > (d->GetYear())) res=1;
else if ((this->GetYear()) < (d->GetYear())) res=-1;
else
if ((this->GetMonth())>(d->GetMonth())) res=1;
else if ((this->GetMonth())<(d->GetMonth())) res=-1;
else
if ((this->GetDay())>(d->GetDay())) res=1;
else if ((this->GetDay())<(d->GetDay())) res=-1;
else res=0;
}
return (res);
}
void Date::successor(const Date *d, Date *s) const
{
assert(isdate(d->GetDay(), d->GetMonth(), d->GetYear()));
int Year, Month, Day;
Year=d->GetYear(); Month=d->GetMonth(); Day=d->GetDay();
// cout<<"OldDate"<<Year<<":"<<Month<<":"<<Day<<endl;
bool leapyear=false;
int daysinmonth=0;
if (((Year % 4==0) && (Year % 100!=0)) || (Year % 400==0))
leapyear=true;
else leapyear=false;
switch (Month)
{
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12: daysinmonth=31; break;
case 4:
case 6:
case 9:
case 11: daysinmonth=30; break;
case 2: if (leapyear) daysinmonth=29; else daysinmonth=28;
}
if ((Day<daysinmonth))
Day++;
else //==
{
Day=1;
if (Month<12) Month++;
else
{
Month=1;
Year++;
}
}
s->year=Year; s->month=Month; s->day=Day; s->defined=true;
// cout<<"NewDate"<<Year<<":"<<Month<<":"<<Day<<endl;
}
bool Date::Adjacent(const Attribute *arg) const
{
const Date *d = (const Date *)arg;
if( this->Compare( d ) == 0 ) return 1; //both undefined or they are equal
if (!IsDefined() || !(arg->IsDefined()))
//one is undefined and another defined
return 0;
else //both defined and they are not equal
{
Date * auxdate=new Date();
successor(this, auxdate);
if (auxdate->Compare(d)==0)
{
delete auxdate;
return 1;
}
successor(d, auxdate);
if (this->Compare(auxdate)==0)
{
delete auxdate;
return 1;
}
delete auxdate;
return 0;
}
}
Date* Date::Clone() const
{
return (new Date( *this));
}
ostream& Date::Print(ostream &os) const
{ if(!IsDefined()) return os << "undef";
return (os << day << "." << month << "." << year);
}
/*
2.2 List Representation
The list representation of a date is
---- (isdefined dd mm yy)
----
2.3 ~In~ and ~Out~ Functions
*/
ListExpr
OutDate( ListExpr typeInfo, Word value )
{
Date* date;
string outputStr;
char buf[100];
date = (Date*)(value.addr);
if (date->IsDefined())
{
sprintf(buf, "%02d.%02d.%d", date->GetDay(),
date->GetMonth(), date->GetYear()); //eg. "01.02.1993"
}
else
{
strcpy(buf,"-");
}
outputStr = buf;
return (nl->StringAtom(outputStr));
}
Word
InDate( const ListExpr typeInfo, const ListExpr instance,
const int errorPos, ListExpr& errorInfo, bool& correct )
{
if (listutils::isSymbolUndefined(instance)) {
Date* date = new Date(false,0,0,0);
correct = true;
return SetWord(date);
}
if (nl->AtomType(instance)!=StringType){
correct = false;
return SetWord(Address(0));
}
Date* date = new Date(false,0,0,0);
string s = nl->StringValue(instance);
if(!date->readFrom(s)){
delete date;
correct = false;
return SetWord(Address(0));
}
correct = true;
return SetWord(date);
}
/***********************************************************************
The following 5 functions must be defined if we want to use ~date~ as
an attribute type in tuple definitions.
************************************************************************/
Word
CreateDate( const ListExpr typeInfo )
{
return (SetWord( new Date( false, 0, 0, 0 )));
}
void
DeleteDate( const ListExpr typeInfo, Word& w )
{
delete (Date*) w.addr;
w.addr = 0;
}
void
CloseDate( const ListExpr typeInfo, Word& w )
{
delete (Date*) w.addr;
w.addr = 0;
}
Word
CloneDate( const ListExpr typeInfo, const Word& w )
{
return SetWord( ((Date *)w.addr)->Clone() );
}
int
SizeOfDate()
{
return sizeof(Date);
}
void*
CastDate( void* addr )
{
return (new (addr) Date);
}
/*
2.4 Function Describing the Signature of the Type Constructor
This one works for type constructor ~date~ , which is an ``atomic'' type.
*/
ListExpr
DateProperty()
{
ListExpr listreplist = nl->TextAtom();
ListExpr examplelist = nl->TextAtom();
nl->AppendText(listreplist,
"Either \"<day>.<month>.<year>\" or \"<year>-<month>-<day>\"");
nl->AppendText(examplelist,
"\"9.5.1955\" or \"09.05.1955\" or \"1955-5-9\" or \"1955-05-09\"");
return (nl->TwoElemList(
nl->FourElemList(nl->StringAtom("Signature"),
nl->StringAtom("Example Type List"),
nl->StringAtom("List Rep"),
nl->StringAtom("Example List")),
nl->FourElemList(nl->StringAtom("-> DATA"),
nl->StringAtom(Date::BasicType()),
listreplist,
examplelist)));
}
/*
2.5 Kind Checking Function
This function checks whether the type constructor is applied correctly. Since
the type constructor ~date~ does not have arguments, this is trivial.
*/
bool
CheckDate( ListExpr type, ListExpr& errorInfo )
{
return (nl->IsEqual(type, Date::BasicType() ));
}
/*
2.6 Creation of the Type Constructor Instance
*/
TypeConstructor date(
Date::BasicType(), //name
DateProperty, //property function describing signature
OutDate, InDate, //Out and In functions
0, 0, //SaveToList and RestoreFromList functions
CreateDate, DeleteDate, //object creation and deletion
0, 0, CloseDate, CloneDate, //object open, save, close, and clone
CastDate, //cast function
SizeOfDate, //sizeof function
CheckDate ); //kind checking function
/*
3 Creating Operators
3.1 Type Mapping Function
Checks whether the correct argument types are supplied for an operator; if so,
returns a list expression for the result type, otherwise the symbol
~typeerror~.
*/
ListExpr
DateInt( ListExpr args )
{
ListExpr arg1;
if ( nl->ListLength(args) == 1 )
{
arg1 = nl->First(args);
if ( nl->IsEqual(arg1, Date::BasicType()))
return nl->SymbolAtom(CcInt::BasicType());
}
return nl->SymbolAtom(Symbol::TYPEERROR());
}
ListExpr
DateDateBool( ListExpr args )
{
ListExpr arg1, arg2;
if ( nl->ListLength(args) == 2 )
{
arg1 = nl->First(args);
arg2 = nl->Second(args);
if ( nl->IsEqual(arg1, Date::BasicType()) &&
nl->IsEqual(arg2, Date::BasicType()) )
return nl->SymbolAtom(CcBool::BasicType());
}
return nl->SymbolAtom(Symbol::TYPEERROR());
}
ListExpr
IntIntIntDate( ListExpr args )
{
ListExpr arg1, arg2, arg3;
if ( nl->ListLength(args) == 3 )
{
arg1 = nl->First(args);
arg2 = nl->Second(args);
arg3 = nl->Third(args);
if ( nl->IsEqual(arg1, CcInt::BasicType()) &&
nl->IsEqual(arg2, CcInt::BasicType()) &&
nl->IsEqual(arg3, CcInt::BasicType()))
return nl->SymbolAtom(Date::BasicType());
}
return nl->SymbolAtom(Symbol::TYPEERROR());
}
ListExpr str2dateTM(ListExpr args){
string err = " string expected";
if(nl->ListLength(args)!=1){
return listutils::typeError(err);
}
ListExpr arg1 = nl->First(args);
if(!listutils::isSymbol(arg1,CcString::BasicType())){
return listutils::typeError(err);
}
return nl->SymbolAtom(Date::BasicType());
}
/*
3.3 Value Mapping Functions
*/
int
dayFun (Word* args, Word& result, int message, Word& local, Supplier s)
{
Date* d;
d = ((Date*)args[0].addr);
result = qp->ResultStorage(s);
int res=d->GetDay();
if (d->IsDefined())
((CcInt*)result.addr)->Set(true, res);
else ((CcInt*)result.addr)->Set(false, res);
return 0;
}
int
monthFun (Word* args, Word& result, int message, Word& local, Supplier s)
{
Date* d;
d = ((Date*)args[0].addr);
result = qp->ResultStorage(s);
int res=d->GetMonth();
if (d->IsDefined())
((CcInt*)result.addr)->Set(true, res);
else ((CcInt*)result.addr)->Set(false, res);
return 0;
}
int
yearFun (Word* args, Word& result, int message, Word& local, Supplier s)
{
Date* d;
d = ((Date*)args[0].addr);
result = qp->ResultStorage(s);
int res=d->GetYear();
if (d->IsDefined())
((CcInt*)result.addr)->Set(true, res);
else ((CcInt*)result.addr)->Set(false, res);
return 0;
}
int
earlierFun (Word* args, Word& result, int message, Word& local, Supplier s)
{
Date* d1;
Date* d2;
d1 = ((Date*)args[0].addr);
d2 = ((Date*)args[1].addr);
result = qp->ResultStorage(s);
bool res;
if (!(d1->IsDefined()) && !(d2->IsDefined())) res=false;
else if (!(d1->IsDefined()) && (d2->IsDefined())) res=true;
else if ((d1->IsDefined()) && !(d2->IsDefined())) res=false;
else
{ if ((d1->GetYear()) > (d2->GetYear())) res=false;
else if ((d1->GetYear()) < (d2->GetYear())) res=true;
else
if ((d1->GetMonth())>(d2->GetMonth())) res=false;
else if ((d1->GetMonth())<(d2->GetMonth())) res=true;
else
if ((d1->GetDay())>=(d2->GetDay()))
res=false;
else res=true;
}
((CcBool*)result.addr)->Set(true, res);
return 0;
}
int
equalFun (Word* args, Word& result, int message, Word& local, Supplier s)
{
Date* d1;
Date* d2;
d1 = ((Date*)args[0].addr);
d2 = ((Date*)args[1].addr);
result = qp->ResultStorage(s);
bool res;
if (!(d1->IsDefined()) && !(d2->IsDefined())) res=true;
else if ((d1->IsDefined()) && (d2->IsDefined()) &&
(d1->GetYear() == d2->GetYear()) &&
(d1->GetMonth()== d2->GetMonth()) &&
(d1->GetDay() == d2->GetDay()))
res=true;
else res=false;
((CcBool*)result.addr)->Set(true, res);
return 0;
}
int
laterFun (Word* args, Word& result, int message, Word& local, Supplier s)
{
Date* d1;
Date* d2;
d1 = ((Date*)args[0].addr);
d2 = ((Date*)args[1].addr);
result = qp->ResultStorage(s);
bool res;
if (!(d1->IsDefined()) && !(d2->IsDefined())) res=false;
else if (!(d1->IsDefined()) && (d2->IsDefined())) res=false;
else if ((d1->IsDefined()) && !(d2->IsDefined())) res=true;
else
{
if ((d1->GetYear()) > (d2->GetYear())) res=true;
else if ((d1->GetYear()) < (d2->GetYear())) res=false;
else
if ((d1->GetMonth())>(d2->GetMonth())) res=true;
else if ((d1->GetMonth())<(d2->GetMonth())) res=false;
else
if ((d1->GetDay())<=(d2->GetDay()))
res=false;
else res=true;
}
((CcBool*)result.addr)->Set(true, res);
return 0;
}
int
dateFun (Word* args, Word& result, int message, Word& local, Supplier s)
{
CcInt *dd;
CcInt *mm;
CcInt *yy;
dd = (CcInt *)args[0].addr;
mm = (CcInt *)args[1].addr;
yy = (CcInt *)args[2].addr;
result = qp->ResultStorage(s);
int Day=dd->GetIntval();
int Month=mm->GetIntval();
int Year=yy->GetIntval();
//bool leapyear;
//int daysinmonth;
Date* res = (Date*) result.addr;
if (isdate(Day, Month, Year)) {
res->Set(true, Day, Month, Year);
} else {
res->Set(false, 0, 0, 0);
}
return 0;
}
int
str2dateFun (Word* args, Word& result, int message, Word& local, Supplier s)
{
result = qp->ResultStorage(s);
Date* res = static_cast<Date*>(result.addr);
CcString* str = static_cast<CcString*>(args[0].addr);
if(!str->IsDefined()){
res->SetDefined(false);
} else {
string st = str->GetValue();
res->ReadFromString(st);
}
return 0;
}
/*
3.4 Definition of Operators
*/
const string DaySpec = "( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" )"
"( <text>(date) -> int</text--->"
"<text>day_of ( _ )</text--->"
"<text>extract the day info. from a date."
"</text--->"
"<text>query day_of ( date1 )</text--->"
") )";
const string MonthSpec = "( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" )"
"( <text>(date) -> int</text--->"
"<text>month_of ( _ )</text--->"
"<text>extract the month info. from a date."
"</text--->"
"<text>query month_of ( date1 )</text--->"
") )";
const string YearSpec = "( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" )"
"( <text>(date) -> int</text--->"
"<text>year_of ( _ )</text--->"
"<text>extract the year info. from a date."
"</text--->"
"<text>query year_of ( date1 )</text--->"
") )";
const string EarlierSpec = "( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" )"
"( <text>(date date) -> bool</text--->"
" <text>_ < _</text--->"
"<text>Earlier predicate.</text--->"
"<text>query date1 < date2</text--->"
") )";
const string EqualSpec = "( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" )"
"( <text>(date date) -> bool</text--->"
"<text>_ = _</text--->"
"<text>Equal predicate.</text--->"
"<text>query date1 = date2</text--->"
") )";
const string LaterSpec = "( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" )"
"( <text>(date date) -> bool</text--->"
"<text>_ > _</text--->"
"<text>Later predicate.</text--->"
"<text>query date1 > date2</text--->"
") )";
const string DateSpec = "( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" )"
"( <text>(int int int) -> date</text--->"
"<text>thedate ( <day>, <month>, <year> ) where"
" <day>, <month> and <year> are of type int"
"</text--->"
"<text>To generate a date.</text--->"
"<text>let date1 = thedate(5,4,2003)</text--->"
") )";
const string str2dateSpec = "( ( \"Signature\" \"Syntax\" \"Meaning\" "
"\"Example\" )"
"( <text>string -> date</text--->"
"<text> str2date(_)"
"</text--->"
"<text>Converts a string to a date. If the string is undefined "
"or is not a valid date, the result will be undefined. "
"Allowed formats are dd.mm.yyyy and yyyy-mm-dd where leading zeros "
" can be omitted."
".</text--->"
"<text>query str2date(\"2011-05-23\") = str2date(\"23.5.2011\")</text--->"
") )";
/*
The above strings are used to explain the signature and the
meaning of operators.
*/
Operator day (
"day_of", //name
DaySpec, //specification
dayFun, //value mapping
Operator::SimpleSelect, //trivial selection function
DateInt //type mapping
);
Operator month (
"month_of", //name
MonthSpec, //specification
monthFun, //value mapping
Operator::SimpleSelect, //trivial selection function
DateInt //type mapping
);
Operator year (
"year_of", //name
YearSpec, //specification
yearFun, //value mapping
Operator::SimpleSelect, //trivial selection function
DateInt //type mapping
);
Operator earlier (
"<", //name
EarlierSpec, //specification
earlierFun, //value mapping
Operator::SimpleSelect, //trivial selection function
DateDateBool //type mapping
);
Operator opequal (
"=", //name
EqualSpec, //specification
equalFun, //value mapping
Operator::SimpleSelect, //trivial selection function
DateDateBool //type mapping
);
Operator later (
">", //name
LaterSpec, //specification
laterFun, //value mapping
Operator::SimpleSelect, //trivial selection function
DateDateBool //type mapping
);
Operator thedate (
"thedate", //name
DateSpec, //specification
dateFun, //value mapping
Operator::SimpleSelect, //trivial selection function
IntIntIntDate //type mapping
);
Operator str2date (
"str2date", //name
str2dateSpec, //specification
str2dateFun, //value mapping
Operator::SimpleSelect, //trivial selection function
str2dateTM //type mapping
);
/*
4 Creating the Algebra
*/
class DateAlgebra : public Algebra
{
public:
DateAlgebra() : Algebra()
{
AddTypeConstructor( &date );
date.AssociateKind(Kind::DATA());
date.AssociateKind(Kind::CSVIMPORTABLE());
date.AssociateKind(Kind::CSVEXPORTABLE());
AddOperator( &day );
AddOperator( &month );
AddOperator( &year );
AddOperator( &earlier );
AddOperator( &opequal);
AddOperator( &later );
AddOperator( &thedate );
AddOperator( &str2date );
}
~DateAlgebra() {};
};
/*
5 Initialization
Each algebra module needs an initialization function. The algebra manager
has a reference to this function if this algebra is included in the list
of required algebras, thus forcing the linker to include this module.
The algebra manager invokes this function to get a reference to the instance
of the algebra class and to provide references to the global nested list
container (used to store constructor, type, operator and object information)
and to the query processor.
The function has a C interface to make it possible to load the algebra
dynamically at runtime.
*/
extern "C"
Algebra*
InitializeDateAlgebra( NestedList* nlRef,
QueryProcessor* qpRef,
AlgebraManager* amRef )
{
nl = nlRef;
qp = qpRef;
am = amRef;
return (new DateAlgebra());
}
/*
6 Other work
6.1 Syntax Specification
We need to write the following DateAlgebra.spec file to indicate the syntax
of the operations in the date algebra:
---- operator year[_]of alias YEAR[_]OF pattern op ( _ )
operator month[_]of alias MONTH[_]OF pattern op ( _ )
operator day[_]of alias DAY[_]OF pattern op ( _ )
operator thedate alias THEDATE pattern op ( _, _, _ )
----
//[->] [$\rightarrow$]
6.2 Display Function
We need to add the following display function into DisplayTTY.h and
DisplayTTY.cpp
(under the secondo/UserInterface/ subdirectary) to display date correctly:
---- void
DisplayTTY::DisplayDate(ListExpr type,ListExpr numType,ListExpr value)
{
ListExpr d, m, y;
if( nl->IsAtom( value ) &&
nl->AtomType( value ) == SymbolType &&
nl->SymbolValue( value ) == "undef" )
{
cout << "UNDEFINED";
}
else
{
d = nl->Second( value ) ;
m = nl->Third( value ) ;
y = nl->Fourth( value );
nl->WriteListExpr( d, cout );
cout << ",";
nl->WriteListExpr( m, cout );
cout << ",";
nl->WriteListExpr( y, cout );
}
}
----
*/
Reference in New Issue Copy Permalink