You've already forked mariadb-columnstore-engine
mirror of
https://github.com/mariadb-corporation/mariadb-columnstore-engine.git
synced 2025-07-30 19:23:07 +03:00
the begginning
This commit is contained in:
726
utils/funcexp/funchelpers.h
Normal file
726
utils/funcexp/funchelpers.h
Normal file
@ -0,0 +1,726 @@
|
||||
/* Copyright (C) 2014 InfiniDB, Inc.
|
||||
|
||||
This program 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; version 2 of
|
||||
the License.
|
||||
|
||||
This program 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 this program; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
||||
MA 02110-1301, USA. */
|
||||
|
||||
// $Id: funchelpers.h 3921 2013-06-19 18:59:56Z bwilkinson $
|
||||
|
||||
/** @file */
|
||||
|
||||
#ifndef FUNCHELPERS_H__
|
||||
#define FUNCHELPERS_H__
|
||||
|
||||
#include <string>
|
||||
|
||||
#ifndef _MSC_VER
|
||||
#ifndef __STDC_FORMAT_MACROS
|
||||
#define __STDC_FORMAT_MACROS
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#include <inttypes.h>
|
||||
#include <boost/algorithm/string/case_conv.hpp>
|
||||
#include <boost/regex.hpp>
|
||||
#include <boost/tokenizer.hpp>
|
||||
#include <boost/date_time/gregorian/gregorian.hpp>
|
||||
|
||||
#include "dataconvert.h"
|
||||
#include "operator.h"
|
||||
#include "intervalcolumn.h"
|
||||
#include "treenode.h"
|
||||
|
||||
#define ULONGLONG_MAX ulonglong_max
|
||||
|
||||
namespace funcexp
|
||||
{
|
||||
namespace helpers
|
||||
{
|
||||
|
||||
// 10 ** i
|
||||
const int64_t powerOf10_c[] = {
|
||||
1ll,
|
||||
10ll,
|
||||
100ll,
|
||||
1000ll,
|
||||
10000ll,
|
||||
100000ll,
|
||||
1000000ll,
|
||||
10000000ll,
|
||||
100000000ll,
|
||||
1000000000ll,
|
||||
10000000000ll,
|
||||
100000000000ll,
|
||||
1000000000000ll,
|
||||
10000000000000ll,
|
||||
100000000000000ll,
|
||||
1000000000000000ll,
|
||||
10000000000000000ll,
|
||||
100000000000000000ll,
|
||||
1000000000000000000ll };
|
||||
|
||||
|
||||
// max integer number of i digits
|
||||
const int64_t maxNumber_c[] = {
|
||||
0ll,
|
||||
9ll,
|
||||
99ll,
|
||||
999ll,
|
||||
9999ll,
|
||||
99999ll,
|
||||
999999ll,
|
||||
9999999ll,
|
||||
99999999ll,
|
||||
999999999ll,
|
||||
9999999999ll,
|
||||
99999999999ll,
|
||||
999999999999ll,
|
||||
9999999999999ll,
|
||||
99999999999999ll,
|
||||
999999999999999ll,
|
||||
9999999999999999ll,
|
||||
99999999999999999ll,
|
||||
999999999999999999ll };
|
||||
|
||||
|
||||
const uint32_t TIMESTAMP_MAX_YEAR = 2038;
|
||||
const uint32_t TIMESTAMP_MIN_YEAR = (1970 - 1);
|
||||
const int TIMESTAMP_MIN_VALUE = 1;
|
||||
const int64_t TIMESTAMP_MAX_VALUE = 0x7FFFFFFFL;
|
||||
const unsigned long long MAX_NEGATIVE_NUMBER = 0x8000000000000000ULL;
|
||||
const long long LONGLONG_MIN = 0x8000000000000000LL;
|
||||
const int INIT_CNT = 9;
|
||||
const unsigned long LFACTOR = 1000000000;
|
||||
const unsigned long long LFACTOR1 = 10000000000ULL;
|
||||
const unsigned long long LFACTOR2 = 100000000000ULL;
|
||||
const unsigned long long ulonglong_max= ~(unsigned long long) 0;
|
||||
|
||||
static std::string monthFullNames[13] =
|
||||
{
|
||||
"NON_VALID",
|
||||
"January",
|
||||
"February",
|
||||
"March",
|
||||
"April",
|
||||
"May",
|
||||
"June",
|
||||
"July",
|
||||
"August",
|
||||
"September",
|
||||
"October",
|
||||
"November",
|
||||
"December"
|
||||
};
|
||||
|
||||
static std::string monthAbNames[13] =
|
||||
{
|
||||
"NON_VALID",
|
||||
"Jan",
|
||||
"Feb",
|
||||
"Mar",
|
||||
"Apr",
|
||||
"May",
|
||||
"Jun",
|
||||
"Jul",
|
||||
"Aug",
|
||||
"Sep",
|
||||
"Oct",
|
||||
"Nov",
|
||||
"Dec"
|
||||
};
|
||||
|
||||
static std::string weekdayFullNames[8] =
|
||||
{
|
||||
"Monday",
|
||||
"Tuesday",
|
||||
"Wednesday",
|
||||
"Thursday",
|
||||
"Friday",
|
||||
"Saturday",
|
||||
"Sunday"
|
||||
};
|
||||
|
||||
static std::string weekdayAbNames[8] =
|
||||
{
|
||||
"Mon",
|
||||
"Tue",
|
||||
"Wed",
|
||||
"Thu",
|
||||
"Fri",
|
||||
"Sat",
|
||||
"Sun"
|
||||
};
|
||||
|
||||
static std::string dayOfMonth[32] =
|
||||
{"0th", "1st", "2nd", "3rd", "4th",
|
||||
"5th", "6th", "7th", "8th", "9th",
|
||||
"10th", "11th", "12th", "13th", "14th",
|
||||
"15th", "16th", "17th", "18th", "19th", "20th",
|
||||
"21st", "22nd", "23rd", "24th", "25th",
|
||||
"26th", "27th", "28th", "29th", "30th",
|
||||
"31st"
|
||||
};
|
||||
|
||||
// Given a date, calculate the number of days since year 0
|
||||
inline uint32_t calc_mysql_daynr( uint32_t year, uint32_t month, uint32_t day )
|
||||
{
|
||||
if( !dataconvert::isDateValid( day, month, year ) )
|
||||
return 0;
|
||||
|
||||
boost::gregorian::date d( year, month, day );
|
||||
// this is the number of days between the beginning of the
|
||||
// Gregorian calendar (November 24, 4714 B.C.) and the starting
|
||||
// date offset in MySQL which is year 0.
|
||||
const uint32_t JULIAN_DAY_OFFSET = 1721060;
|
||||
return d.julian_day() - JULIAN_DAY_OFFSET;
|
||||
}
|
||||
|
||||
// convert from a MySQL day number (offset from year 0) to a date
|
||||
inline void get_date_from_mysql_daynr(long daynr,dataconvert::DateTime & dateTime)
|
||||
{
|
||||
// the MySQL day numbers for min/max boost supported dates
|
||||
const int BOOST_START_OFFSET = 511340; // 1400-01-01
|
||||
const int BOOST_END_OFFSET = 3652424; // 9999-12-31
|
||||
|
||||
if( daynr < BOOST_START_OFFSET || daynr > BOOST_END_OFFSET )
|
||||
{
|
||||
dateTime.year= dateTime.month = dateTime.day =0;
|
||||
}
|
||||
else
|
||||
{
|
||||
boost::gregorian::date d(1400,1,1);
|
||||
d += boost::gregorian::date_duration( daynr - BOOST_START_OFFSET );
|
||||
dateTime.year = d.year();
|
||||
dateTime.month = d.month();
|
||||
dateTime.day = d.day();
|
||||
}
|
||||
}
|
||||
|
||||
// Returns the weekday index for a given date:
|
||||
// if sundayFirst:
|
||||
// 0 = Sunday, 1 = Monday, ..., 6 = Saturday
|
||||
// else:
|
||||
// 0 = Monday, 1 = Tuesday, ..., 6 = Sunday
|
||||
inline uint32_t calc_mysql_weekday( uint32_t year, uint32_t month, uint32_t day, bool sundayFirst )
|
||||
{
|
||||
if( !dataconvert::isDateValid( day, month, year ) )
|
||||
return 0;
|
||||
|
||||
boost::gregorian::date d( year, month, day );
|
||||
uint32_t ret = d.day_of_week();
|
||||
return sundayFirst ? ret : (ret + 6) % 7;
|
||||
}
|
||||
|
||||
// Flags for calc_mysql_week
|
||||
const uint32_t WEEK_MONDAY_FIRST = 1;
|
||||
const uint32_t WEEK_NO_ZERO = 2;
|
||||
const uint32_t WEEK_GT_THREE_DAYS = 4;
|
||||
|
||||
// Takes a MySQL WEEK() function mode setting and converts to a bitmask
|
||||
// used by calc_mysql_week()
|
||||
inline int16_t convert_mysql_mode_to_modeflags( int16_t mode )
|
||||
{
|
||||
// For some crazy reason, MySQL assigns modes 1, 3, 4, and 6 to use
|
||||
// the setting for >3 days in first week which does not align to
|
||||
// any particular bit. This small piece of code sets bit 2
|
||||
// (WEEK_GT_THREE_DAYS) for modes 1 & 3 and disables for modes
|
||||
// 5 & 7 which is exactly what we want.
|
||||
if( mode & WEEK_MONDAY_FIRST )
|
||||
mode ^= WEEK_GT_THREE_DAYS;
|
||||
|
||||
return mode;
|
||||
}
|
||||
|
||||
// Returns a week index conforming to the MySQL WEEK() function. Note
|
||||
// that modeflags is not the MySQL mode - it is a bitmask of the abvoe
|
||||
// 3 flags. The utility function convert_mysql_mode_to_modeflags should
|
||||
// be applied to the MySQL mode before calling this function (or the
|
||||
// flags may be used directly). The optional argument is for callers
|
||||
// that need to know the year that the week actually corresponds to -
|
||||
// see MySQL documentation for how the year returned can be different
|
||||
// than the year of the input date
|
||||
inline uint32_t calc_mysql_week( uint32_t year, uint32_t month, uint32_t day,
|
||||
int16_t modeflags,
|
||||
uint32_t* weekyear = 0 )
|
||||
{
|
||||
// need to make sure that the date is valid for boost::gregorian::date
|
||||
if( !dataconvert::isDateValid( day, month, year ) )
|
||||
return 0;
|
||||
|
||||
boost::gregorian::date d( year, month, day );
|
||||
|
||||
// default this to the year of the input date - will update in the
|
||||
// scenarios where it is either 1 behind or 1 ahead
|
||||
if( weekyear )
|
||||
*weekyear = d.year();
|
||||
|
||||
// get a date object for the first day of they year in question
|
||||
boost::gregorian::date yearfirst = boost::gregorian::date(d.year(),1,1);
|
||||
|
||||
// figure out which day of week Jan-01 is
|
||||
uint32_t firstweekday = calc_mysql_weekday( d.year(), 1, 1, !( modeflags & WEEK_MONDAY_FIRST ) );
|
||||
|
||||
// calculate the offset to the first week starting day
|
||||
uint32_t firstoffset = firstweekday ? ( 7 - firstweekday ) : 0;
|
||||
|
||||
// julian day number for the first day of the first week
|
||||
uint32_t baseday = yearfirst.julian_day() + firstoffset;
|
||||
|
||||
// if using a modeflags where the first week must have >3 days in this year
|
||||
// we need to check where firstweekday fell. There are 3 cases for Jan-01
|
||||
// 1) Jan-01 fell on week start - there are obviously at least
|
||||
// three days this year and baseday already correct
|
||||
// 2) Jan-01 fell on weekday 1 - 3 - this means that our baseday is
|
||||
// pointing to next week but there must be at least 3 days this year
|
||||
// so we need to adjust baseday back by one week
|
||||
// 3) Jan-01 fell on weekday 4 - 6 - this means there cannot be >3
|
||||
// days in the week with Jan 01 so our baseday is already correct
|
||||
if( modeflags & WEEK_GT_THREE_DAYS )
|
||||
{
|
||||
if( firstweekday > 0 && firstweekday < 4 )
|
||||
{
|
||||
baseday = baseday - 7;
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t weeknum = 0;
|
||||
if( d.julian_day() < baseday && ( modeflags & WEEK_NO_ZERO ) )
|
||||
{
|
||||
// this is somewhat of a pain - since we aren't using a 0 week, the date
|
||||
// is actually going to be in the last week of last year and we need to
|
||||
// figure out which number that is. This code is identical to above
|
||||
// except we are compuing for last year instead of current year.
|
||||
boost::gregorian::date lastyearfirst = boost::gregorian::date(d.year()-1,1,1);
|
||||
firstweekday = calc_mysql_weekday( d.year()-1, 1, 1, !( modeflags & WEEK_MONDAY_FIRST ) );
|
||||
firstoffset = firstweekday ? ( 7 - firstweekday ) : 0;
|
||||
baseday = lastyearfirst.julian_day() + firstoffset;
|
||||
|
||||
// same logic as above
|
||||
if( modeflags & WEEK_GT_THREE_DAYS )
|
||||
{
|
||||
if( firstweekday > 0 && firstweekday < 4 )
|
||||
{
|
||||
baseday = baseday - 7;
|
||||
}
|
||||
}
|
||||
weeknum = (d.julian_day() - baseday)/ 7 + 1;
|
||||
|
||||
if( weekyear )
|
||||
*weekyear = d.year() - 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
weeknum = (d.julian_day() >= baseday) ? (d.julian_day() - baseday)/ 7 + 1 : 0;
|
||||
|
||||
if( ( modeflags & WEEK_GT_THREE_DAYS ) &&
|
||||
( modeflags & WEEK_NO_ZERO ) && weeknum > 52 )
|
||||
{
|
||||
// if this happens we aren't sure whether the week will be 53 or 1.
|
||||
// to get 53, we know this has to be a December date and can subtract
|
||||
// our date from 32 to figure out how many days of this week
|
||||
uint32_t daysthisyear = 32 - d.day();
|
||||
uint32_t firstweekday = calc_mysql_weekday( d.year(), d.month(), d.day(), !( modeflags & 0x1 ) );
|
||||
// to be 1st week of next year there must be > 3 days of next year
|
||||
if( ( firstweekday + daysthisyear ) < 4 )
|
||||
{
|
||||
weeknum = 1;
|
||||
if( weekyear )
|
||||
*weekyear = d.year() + 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return weeknum;
|
||||
}
|
||||
|
||||
inline bool calc_time_diff(int64_t time1, int64_t time2, int l_sign, long long *seconds_out, long long *microseconds_out)
|
||||
{
|
||||
int64_t days;
|
||||
bool neg;
|
||||
int64_t microseconds;
|
||||
|
||||
uint64_t year1 = 0,
|
||||
month1 = 0,
|
||||
day1 = 0,
|
||||
hour1 = 0,
|
||||
min1 = 0,
|
||||
sec1 = 0,
|
||||
msec1 = 0;
|
||||
|
||||
uint64_t year2 = 0,
|
||||
month2 = 0,
|
||||
day2 = 0,
|
||||
hour2 = 0,
|
||||
min2 = 0,
|
||||
sec2 = 0,
|
||||
msec2 = 0;
|
||||
|
||||
year1 = (uint32_t)((time1 >> 48) & 0xffff);
|
||||
month1 = (uint32_t)((time1 >> 44) & 0xf);
|
||||
day1 = (uint32_t)((time1 >> 38) & 0x3f);
|
||||
hour1 = (uint32_t)((time1 >> 32) & 0x3f);
|
||||
min1 = (uint32_t)((time1 >> 26) & 0x3f);
|
||||
sec1 = (uint32_t)((time1 >> 20) & 0x3f);
|
||||
msec1 = (uint32_t)((time1 & 0xfffff));
|
||||
|
||||
year2 = (uint32_t)((time2 >> 48) & 0xffff);
|
||||
month2 = (uint32_t)((time2 >> 44) & 0xf);
|
||||
day2 = (uint32_t)((time2 >> 38) & 0x3f);
|
||||
hour2 = (uint32_t)((time2 >> 32) & 0x3f);
|
||||
min2 = (uint32_t)((time2 >> 26) & 0x3f);
|
||||
sec2 = (uint32_t)((time2 >> 20) & 0x3f);
|
||||
msec2 = (uint32_t)((time2 & 0xfffff));
|
||||
|
||||
days= calc_mysql_daynr(year1, month1, day1);
|
||||
|
||||
days-= l_sign*calc_mysql_daynr(year2, month2, day2);
|
||||
|
||||
microseconds= ((long long)days*(long)(86400) +
|
||||
(long long)(hour1*3600L +
|
||||
min1*60L +
|
||||
sec1) -
|
||||
l_sign*(long long)(hour2*3600L +
|
||||
min2*60L +
|
||||
sec2)) * (long long)(1000000) +
|
||||
(long long)msec1 -
|
||||
l_sign*(long long)msec2;
|
||||
|
||||
neg= 0;
|
||||
if (microseconds < 0)
|
||||
{
|
||||
microseconds= -microseconds;
|
||||
neg= 1;
|
||||
}
|
||||
*seconds_out= microseconds/1000000L;
|
||||
*microseconds_out= (long long) (microseconds%1000000L);
|
||||
return neg;
|
||||
}
|
||||
|
||||
inline int power ( int16_t a ) {
|
||||
int b = 1;
|
||||
for ( int i=0 ; i < a ; i++ )
|
||||
{
|
||||
b = b * 10;
|
||||
}
|
||||
return b;
|
||||
}
|
||||
|
||||
inline void decimalPlaceDec(int64_t& d, int64_t& p, int8_t& s)
|
||||
{
|
||||
// find new scale if D < s
|
||||
if (d < s)
|
||||
{
|
||||
int64_t t = s;
|
||||
s = d; // the new scale
|
||||
d -= t;
|
||||
int64_t i = (d >= 0) ? d : (-d);
|
||||
while (i--)
|
||||
p *= 10;
|
||||
}
|
||||
else
|
||||
{
|
||||
d = s;
|
||||
}
|
||||
}
|
||||
|
||||
inline uint32_t convertMonth (std::string month)
|
||||
{
|
||||
uint32_t value = 0;
|
||||
|
||||
boost::algorithm::to_lower(month);
|
||||
|
||||
if ( month == "jan" || month == "january" )
|
||||
{
|
||||
value = 1;
|
||||
}
|
||||
else if ( month == "feb" || month == "february" )
|
||||
{
|
||||
value = 2;
|
||||
}
|
||||
else if ( month == "mar" || month == "march" )
|
||||
{
|
||||
value = 3;
|
||||
}
|
||||
else if ( month == "apr" || month == "april" )
|
||||
{
|
||||
value = 4;
|
||||
}
|
||||
else if ( month == "may" )
|
||||
{
|
||||
value = 5;
|
||||
}
|
||||
else if ( month == "jun" || month == "june" )
|
||||
{
|
||||
value = 6;
|
||||
}
|
||||
else if ( month == "jul" || month == "july" )
|
||||
{
|
||||
value = 7;
|
||||
}
|
||||
else if ( month == "aug" || month == "august" )
|
||||
{
|
||||
value = 8;
|
||||
}
|
||||
else if ( month == "sep" || month == "september" )
|
||||
{
|
||||
value = 9;
|
||||
}
|
||||
else if ( month == "oct" || month == "october" )
|
||||
{
|
||||
value = 10;
|
||||
}
|
||||
else if ( month == "nov" || month == "november" )
|
||||
{
|
||||
value = 11;
|
||||
}
|
||||
else if ( month == "dec" || month == "december" )
|
||||
{
|
||||
value = 12;
|
||||
}
|
||||
else
|
||||
{
|
||||
value = 0;
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
class to_lower
|
||||
{
|
||||
public:
|
||||
char operator() (char c) const // notice the return type
|
||||
{
|
||||
return tolower(c);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
inline int getNumbers( const std::string& expr, int64_t *array, execplan::OpType funcType)
|
||||
{
|
||||
int index = 0;
|
||||
|
||||
int funcNeg = 1;
|
||||
if ( funcType == execplan::OP_SUB )
|
||||
funcNeg = -1;
|
||||
|
||||
if ( expr.size() == 0 )
|
||||
return 0;
|
||||
|
||||
// @bug 4703 reworked this code to avoid use of incrementally
|
||||
// built string to hold temporary values while
|
||||
// scanning expr for numbers. This function is now
|
||||
// covered by a unit test in tdriver.cpp
|
||||
bool foundNumber = false;
|
||||
int64_t number = 0;
|
||||
int neg = 1;
|
||||
for ( unsigned int i=0 ; i < expr.size() ; i++ )
|
||||
{
|
||||
char value = expr[i];
|
||||
if ( (value >= '0' && value <= '9') )
|
||||
{
|
||||
foundNumber = true;
|
||||
number = ( number * 10 ) + ( value - '0' );
|
||||
}
|
||||
else if ( value == '-' && !foundNumber )
|
||||
{
|
||||
neg = -1;
|
||||
}
|
||||
else if ( value == '-')
|
||||
{
|
||||
// this is actually an error condition - it means that
|
||||
// input came in with something like NN-NN (i.e. a dash
|
||||
// between two numbers. To match prior code we will
|
||||
// return the number up to the dash and just return
|
||||
array[index] = number * funcNeg * neg;
|
||||
index++;
|
||||
|
||||
return index;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( foundNumber )
|
||||
{
|
||||
array[index] = number * funcNeg * neg;
|
||||
number = 0;
|
||||
neg = 1;
|
||||
index++;
|
||||
|
||||
if ( index > 9 )
|
||||
return index;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ( foundNumber )
|
||||
{
|
||||
array[index] = number * funcNeg * neg;
|
||||
index++;
|
||||
}
|
||||
|
||||
return index;
|
||||
}
|
||||
|
||||
|
||||
inline int getNumbers( const std::string& expr, int *array, execplan::OpType funcType)
|
||||
{
|
||||
int index = 0;
|
||||
|
||||
int funcNeg = 1;
|
||||
if ( funcType == execplan::OP_SUB )
|
||||
funcNeg = -1;
|
||||
|
||||
if ( expr.size() == 0 )
|
||||
return 0;
|
||||
|
||||
// @bug 4703 reworked this code to avoid use of incrementally
|
||||
// built string to hold temporary values while
|
||||
// scanning expr for numbers. This function is now
|
||||
// covered by a unit test in tdriver.cpp
|
||||
bool foundNumber = false;
|
||||
int number = 0;
|
||||
int neg = 1;
|
||||
for ( unsigned int i=0 ; i < expr.size() ; i++ )
|
||||
{
|
||||
char value = expr[i];
|
||||
if ( (value >= '0' && value <= '9') )
|
||||
{
|
||||
foundNumber = true;
|
||||
number = ( number * 10 ) + ( value - '0' );
|
||||
}
|
||||
else if ( value == '-' && !foundNumber )
|
||||
{
|
||||
neg = -1;
|
||||
}
|
||||
else if ( value == '-')
|
||||
{
|
||||
// this is actually an error condition - it means that
|
||||
// input came in with something like NN-NN (i.e. a dash
|
||||
// between two numbers. To match prior code we will
|
||||
// return the number up to the dash and just return
|
||||
array[index] = number * funcNeg * neg;
|
||||
index++;
|
||||
|
||||
return index;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( foundNumber )
|
||||
{
|
||||
array[index] = number * funcNeg * neg;
|
||||
number = 0;
|
||||
neg = 1;
|
||||
index++;
|
||||
|
||||
if ( index > 9 )
|
||||
return index;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ( foundNumber )
|
||||
{
|
||||
array[index] = number * funcNeg * neg;
|
||||
index++;
|
||||
}
|
||||
|
||||
return index;
|
||||
}
|
||||
|
||||
inline int dayOfWeek(std::string day) //Sunday = 0
|
||||
{
|
||||
int value = -1;
|
||||
boost::to_lower(day);
|
||||
|
||||
if ( day == "sunday" || day == "sun" )
|
||||
{
|
||||
value = 0;
|
||||
}
|
||||
else if ( day == "monday" || day == "mon" )
|
||||
{
|
||||
value = 1;
|
||||
}
|
||||
else if ( day == "tuesday" || day == "tue" )
|
||||
{
|
||||
value = 2;
|
||||
}
|
||||
else if ( day == "wednesday" || day == "wed" )
|
||||
{
|
||||
value = 3;
|
||||
}
|
||||
else if ( day == "thursday" || day == "thu" )
|
||||
{
|
||||
value = 4;
|
||||
}
|
||||
else if ( day == "friday" || day == "fri" )
|
||||
{
|
||||
value = 5;
|
||||
}
|
||||
else if ( day == "saturday" || day == "sat" )
|
||||
{
|
||||
value = 6;
|
||||
}
|
||||
else
|
||||
{
|
||||
value = -1;
|
||||
}
|
||||
return value;
|
||||
|
||||
}
|
||||
|
||||
inline
|
||||
string intToString(int64_t i)
|
||||
{
|
||||
char buf[32];
|
||||
#ifndef _MSC_VER
|
||||
snprintf(buf, 32, "%" PRId64 "", i);
|
||||
#else
|
||||
snprintf(buf, 32, "%lld", i);
|
||||
#endif
|
||||
return buf;
|
||||
}
|
||||
|
||||
inline
|
||||
string uintToString(uint64_t i)
|
||||
{
|
||||
char buf[32];
|
||||
#ifndef _MSC_VER
|
||||
snprintf(buf, 32, "%" PRIu64 "", i);
|
||||
#else
|
||||
snprintf(buf, 32, "%llu", i);
|
||||
#endif
|
||||
return buf;
|
||||
}
|
||||
|
||||
inline
|
||||
string doubleToString(double d)
|
||||
{
|
||||
// double's can be *really* long to print out. Max mysql
|
||||
// is e308 so allow for 308 + 36 decimal places minimum.
|
||||
char buf[384];
|
||||
snprintf(buf, 384, "%f", d);
|
||||
return buf;
|
||||
}
|
||||
|
||||
//@bug6146, remove duplicate function with incorrect impl. Use the DataConvert::decimalToString()
|
||||
//string decimalToString( execplan::IDB_Decimal x, int p )
|
||||
|
||||
|
||||
uint64_t dateAdd( uint64_t time, const std::string& expr, execplan::IntervalColumn::interval_type unit, bool dateType, execplan::OpType funcType );
|
||||
const std::string IDB_date_format(const dataconvert::DateTime&, const std::string&);
|
||||
const std::string timediff(int64_t, int64_t);
|
||||
const char *convNumToStr(int64_t, char*, int);
|
||||
|
||||
} //namespace funcexp::helpers
|
||||
} //namespace funcexp
|
||||
|
||||
#endif
|
Reference in New Issue
Block a user