round.java

mysql集群

/*****************************************************************************
      SQLJEP - Java SQL Expression Parser 0.2
      November 1 2006
         (c) Copyright 2006, Alexey Gaidukov
      SQLJEP Author: Alexey Gaidukov

      SQLJEP is based on JEP 2.24 (http://www.singularsys.com/jep/)
           (c) Copyright 2002, Nathan Funk
 
      See LICENSE.txt for license information.
*****************************************************************************/

package com.meidusa.amoeba.sqljep.function;

import java.lang.Math;
import java.util.Calendar;
import java.sql.Timestamp;
import java.math.*;

import static com.meidusa.amoeba.sqljep.function.Trunc.*;
import static java.util.Calendar.*;

import com.meidusa.amoeba.sqljep.function.PostfixCommand;
import com.meidusa.amoeba.sqljep.ASTFunNode;
import com.meidusa.amoeba.sqljep.JepRuntime;
import com.meidusa.amoeba.sqljep.ParseException;

public class Round extends PostfixCommand {
	private static final String PARAM_EXCEPTION = "Scale in round shoud be integer";

	final public int getNumberOfParameters() {
		return -1;
	}
	
	public Comparable<?>[] evaluate(ASTFunNode node, JepRuntime runtime) throws ParseException {
		node.childrenAccept(runtime.ev, null);
		int num = node.jjtGetNumChildren();
		if (num == 1) {
			Comparable<?>  param1 = runtime.stack.pop();
			return new Comparable<?>[]{param1};
		}
		else if (num == 2) {
			Comparable<?>  param2 = runtime.stack.pop();
			Comparable<?>  param1 = runtime.stack.pop();
			return new Comparable<?>[]{param1,param2};
		} else {
			// remove all parameters from stack and push null
			removeParams(runtime.stack, num);
			throw new ParseException(PARAMS_NUMBER+" for trunc");
		}
	}

	public static Comparable<?>  round(Comparable<?>  param, Calendar cal) throws ParseException {
		if (param == null) {
			return null;
		}
		if (param instanceof String) {
			param = parse((String)param);
		}
		if (param instanceof BigDecimal) {		// BigInteger is not supported
			BigDecimal b = ((BigDecimal)param).setScale(0, BigDecimal.ROUND_HALF_UP);
			try {
				return b.longValueExact();
			} catch (ArithmeticException e) {
			}
			return b;
		}
		if (param instanceof Double || param instanceof Float) {
			return Math.round(((Number)param).doubleValue());
		}
		if (param instanceof Number) {		// Long, Integer, Short, Byte 
			return param;
		}
		if (param instanceof Timestamp) {
			Timestamp ts = (Timestamp)param;
			cal.setTimeInMillis(ts.getTime());
			int year = cal.get(YEAR);
			int month = cal.get(MONTH);
			int date = cal.get(DATE);
			int hour = cal.get(HOUR_OF_DAY);
			cal.clear();
			if (hour > 11) {
				date++;
			}
			cal.set(year, month, date);
			return new Timestamp(cal.getTimeInMillis());
		}
		throw new ParseException(WRONG_TYPE+" round("+param.getClass()+")");
	}

	public static Comparable<?>  round(Comparable<?>  param1, Comparable<?>  param2, Calendar cal) throws ParseException {
		if (param1 == null || param2 == null) {
			return null;
		}
		if (param1 instanceof String) {
			param1 = parse((String)param1);
		}
		if (param1 instanceof Number) {
			int scale;
			try {
				scale = getInteger(param2);
			} catch (ParseException e) {
				throw new ParseException(PARAM_EXCEPTION);
			}
			if (scale < 0) {
				return ZERO;
			}
			if (param1 instanceof BigDecimal) {		// BigInteger is not supported
				return ((BigDecimal)param1).setScale(scale, BigDecimal.ROUND_HALF_UP);
			}
			if (param1 instanceof Double || param1 instanceof Float) {
				double d = ((Number)param1).doubleValue();
				long mult = 1;
				for (int i = 0; i < scale; i++) {
					mult *= 10;
				}
				d *= mult;
				return (Math.round(d))/mult;
			}
			if (param1 instanceof Number) {		// Long, Integer, Short, Byte 
				return param1;
			}
			throw new ParseException(WRONG_TYPE+" round("+param1.getClass()+","+param2.getClass()+")");
		}
		else if (param1 instanceof java.util.Date) {
			if (param2 instanceof String) {
				String s = (String)param2;
				java.util.Date d = (java.util.Date)param1;
				cal.setTimeInMillis(d.getTime());
				if (s.equalsIgnoreCase("CC") || s.equalsIgnoreCase("SCC")) {
					if (d instanceof java.sql.Time) {
						throw new ParseException(TIME_EXCEPTION);
					}
					int year = cal.get(YEAR);
					int year1 = (year/100)*100;
					if (year-year1 > 50) {
						year1 += 100;
					}
					cal.clear();
					cal.set(year1+1, 0, 1);
					return new Timestamp(cal.getTimeInMillis());
				}
				else if (s.equalsIgnoreCase("SYYYY") || s.equalsIgnoreCase("YYYY") || s.equalsIgnoreCase("YYY") || 
							s.equalsIgnoreCase("Y") || s.equalsIgnoreCase("YEAR") || s.equalsIgnoreCase("SYEAR")) {
					if (d instanceof java.sql.Time) {
						throw new ParseException(TIME_EXCEPTION);
					}
					int year = cal.get(YEAR);
					int month = cal.get(MONTH);
					if (month > 6) {
						year++;
					}
					cal.clear();
					cal.set(year, 0, 1);
					return new Timestamp(cal.getTimeInMillis());
				}
				else if (s.equalsIgnoreCase("IYYY") || s.equalsIgnoreCase("IY") || s.equalsIgnoreCase("I")) {
					throw new ParseException(NOT_IMPLIMENTED_EXCEPTION);
				}
				else if (s.equalsIgnoreCase("Q")) {
					if (d instanceof java.sql.Time) {
						throw new ParseException(TIME_EXCEPTION);
					}
					int year = cal.get(YEAR);
					int month = cal.get(MONTH);
					int q = (month/3)*3;
					if (month > q+1) {
						q++;
					}
					else if (month > q) {
						int day = cal.get(DAY_OF_MONTH);
						if (day > 15) {
							q++;
						}
					}
					cal.clear();
					cal.set(year, q, 1);
					return new Timestamp(cal.getTimeInMillis());
				}
				else if (s.equalsIgnoreCase("MONTH") || s.equalsIgnoreCase("MON") || 
							s.equalsIgnoreCase("MM") || s.equalsIgnoreCase("RM")) {
					if (d instanceof java.sql.Time) {
						throw new ParseException(TIME_EXCEPTION);
					}
					int year = cal.get(YEAR);
					int month = cal.get(MONTH);
					int day = cal.get(DAY_OF_MONTH);
					if (day > 15) {
						month++;
					}
					cal.clear();
					cal.set(year, month, 1);
					return new Timestamp(cal.getTimeInMillis());
				}
				else if (s.equalsIgnoreCase("WW")) {
					if (d instanceof java.sql.Time) {
						throw new ParseException(TIME_EXCEPTION);
					}
					int year = cal.get(YEAR);
					int month = cal.get(MONTH);
					int day = cal.get(DAY_OF_MONTH);
					int dw = cal.get(DAY_OF_WEEK);
					cal.clear();
					cal.set(year, 0, 1);
					int dayOfWeek = cal.get(DAY_OF_WEEK);
					int delta = (dw<dayOfWeek ? 7-(dayOfWeek-dw) : dw-dayOfWeek);
					if (delta > 2) {
						delta = delta-7;
					}
					cal.set(year, month, day-delta);
					return new Timestamp(cal.getTimeInMillis());
				}
				else if (s.equalsIgnoreCase("W")) {
					if (d instanceof java.sql.Time) {
						throw new ParseException(TIME_EXCEPTION);
					}
					int year = cal.get(YEAR);
					int month = cal.get(MONTH);
					int day = cal.get(DAY_OF_MONTH);
					int dw = cal.get(DAY_OF_WEEK);
					cal.clear();
					cal.set(year, month, 1);
					int dayOfWeek = cal.get(DAY_OF_WEEK);
					int delta = (dw<dayOfWeek ? 7-(dayOfWeek-dw) : dw-dayOfWeek);
					if (delta > 2) {
						delta = delta-7;
					}
					cal.set(year, month, day-delta);
					return new Timestamp(cal.getTimeInMillis());
				}
				else if (s.equalsIgnoreCase("IW")) {
					throw new ParseException(NOT_IMPLIMENTED_EXCEPTION);
				}
				else if (s.equalsIgnoreCase("DAY") || s.equalsIgnoreCase("DY") || s.equalsIgnoreCase("D")) {
					if (d instanceof java.sql.Time) {
						throw new ParseException(TIME_EXCEPTION);
					}
					int year = cal.get(YEAR);
					int month = cal.get(MONTH);
					int day = cal.get(DAY_OF_MONTH);
					int dw = cal.get(DAY_OF_WEEK);
					int delta = dw-cal.getFirstDayOfWeek();
					if (delta > 2) {
						delta = delta-7;
					}
					cal.clear();
					cal.set(year, month, day-delta);
					return new Timestamp(cal.getTimeInMillis());
				}
				else if (s.equalsIgnoreCase("HH") || s.equalsIgnoreCase("HH12") || s.equalsIgnoreCase("HH24")) {
					if (d instanceof java.sql.Date) {
						throw new ParseException(DATE_EXCEPTION);
					}
					int minute = cal.get(MINUTE);
					if (minute >= 30) {
						int hour = cal.get(HOUR_OF_DAY);
						cal.add(HOUR_OF_DAY, 1);
					}
					cal.set(MINUTE, 0);
					cal.set(SECOND, 0);
					cal.set(MILLISECOND, 0);
					return new Timestamp(cal.getTimeInMillis());
				}
				else if (s.equalsIgnoreCase("MI")) {
					if (d instanceof java.sql.Date) {
						throw new ParseException(DATE_EXCEPTION);
					}
					int second = cal.get(SECOND);
					if (second >= 30) {
						int minute = cal.get(MINUTE);
						cal.add(MINUTE, 1);
					}
					cal.set(SECOND, 0);
					cal.set(MILLISECOND, 0);
					return new Timestamp(cal.getTimeInMillis());
				} else {
					throw new ParseException(FORMAT_EXCEPTION);
				}
			}
		}
		throw new ParseException(WRONG_TYPE+" trunc("+param1.getClass()+","+param2.getClass()+")");
	}

	public Comparable<?> getResult(Comparable<?>... comparables)
			throws ParseException {
		if(comparables.length ==1){
			return round(comparables[0],JepRuntime.getCalendar());
		}else{
			return round(comparables[0],comparables[2],JepRuntime.getCalendar());
		}
	}
}