expression.cs

C#数据库中间层处理,支持主流数据库,如sql、oracle等

				case CONCAT:
					iDataType = Column.VARCHAR;

					break;

				case NOT:

				case EQUAL:

				case BIGGER_EQUAL:

				case BIGGER:

				case SMALLER:

				case SMALLER_EQUAL:

				case NOT_EQUAL:

				case LIKE:

				case AND:

				case OR:

				case IN:

				case EXISTS:
					iDataType = Column.BIT;

					break;

				case COUNT:
					iDataType = Column.INTEGER;

					break;

				case MAX:

				case MIN:

				case SUM:

				case AVG:
					iDataType = eArg.iDataType;

					break;

				case CONVERT:

					// it is already set
					break;

				case IFNULL:

				case CASEWHEN:
					iDataType = eArg2.iDataType;

					break;
			}
		}

		/**
		 * Method declaration
		 *
		 *
		 * @return
		 */
		public bool isResolved() 
		{
			if (iType == VALUE) 
			{
				return true;
			}

			if (iType == COLUMN) 
			{
				return tFilter != null;
			}

			// todo: could recurse here, but never miss a 'false'!
			return false;
		}

		/**
		 * Method declaration
		 *
		 *
		 * @param i
		 *
		 * @return
		 */
		public static bool isCompare(int i) 
		{
			switch (i) 
			{

				case EQUAL:

				case BIGGER_EQUAL:

				case BIGGER:

				case SMALLER:

				case SMALLER_EQUAL:

				case NOT_EQUAL:
					return true;
			}

			return false;
		}

		/**
		 * Method declaration
		 *
		 *
		 * @return
		 */
		public string getTableName() 
		{
			if (iType == ASTERIX) 
			{
				return sTable;
			}

			if (iType == COLUMN) 
			{
				if (tFilter == null) 
				{
					return sTable;
				} 
				else 
				{
					return tFilter.getTable().getName();
				}
			}

			// todo
			return "";
		}

		/**
		 * Method declaration
		 *
		 *
		 * @return
		 */
		public string getColumnName() 
		{
			if (iType == COLUMN) 
			{
				if (tFilter == null) 
				{
					return sColumn;
				} 
				else 
				{
					return tFilter.getTable().getColumnName(iColumn);
				}
			}

			return getAlias();
		}

		/**
		 * Method declaration
		 *
		 *
		 * @throws Exception
		 */
		public void swapCondition() 
		{
			int i = EQUAL;

			switch (iType) 
			{

				case BIGGER_EQUAL:
					i = SMALLER_EQUAL;

					break;

				case SMALLER_EQUAL:
					i = BIGGER_EQUAL;

					break;

				case SMALLER:
					i = BIGGER;

					break;

				case BIGGER:
					i = SMALLER;

					break;

				case EQUAL:
					break;

				default:
					Trace.assert(false, "Expression.swapCondition");
			}

			iType = i;

			Expression e = eArg;

			eArg = eArg2;
			eArg2 = e;
		}

		/**
		 * Method declaration
		 *
		 *
		 * @param type
		 *
		 * @return
		 *
		 * @throws Exception
		 */
		public object getValue(int type) 
		{
			object o = getValue();

			if (o == null || iDataType == type) 
			{
				return o;
			}

			string s = Column.convertobject(o);

			return Column.convertstring(s, type);
		}

		/**
		 * Method declaration
		 *
		 *
		 * @return
		 */
		public int getDataType() 
		{
			return iDataType;
		}

		/**
		 * Method declaration
		 *
		 *
		 * @return
		 *
		 * @throws Exception
		 */
		public object getValue() 
		{
			switch (iType) 
			{

				case VALUE:
					return oData;

				case COLUMN:
					try 
					{
						return tFilter.oCurrentData[iColumn];
					} 
					catch (Exception e) 
					{
						throw Trace.error(Trace.COLUMN_NOT_FOUND, sColumn);
					}

					/*				case FUNCTION:
										return fFunction.getValue();
					*/
				case QUERY:
					return sSelect.getValue(iDataType);

				case NEGATE:
					return Column.negate(eArg.getValue(iDataType), iDataType);

				case COUNT:

					// count(*): sum(1); count(col): sum(col<>null)
					if (eArg.iType == ASTERIX || eArg.getValue() != null) 
					{
						return 1;
					}

					return 0;

				case MAX:

				case MIN:

				case SUM:

				case AVG:
					return eArg.getValue();

				case EXISTS:
					return test();

				case CONVERT:
					return eArg.getValue(iDataType);

				case CASEWHEN:
					if (eArg.test()) 
					{
						return eArg2.eArg.getValue();
					} 
					else 
					{
						return eArg2.eArg2.getValue();
					}
			}

			// todo: simplify this
			object a = null, b = null;

			if (eArg != null) 
			{
				a = eArg.getValue(iDataType);
			}

			if (eArg2 != null) 
			{
				b = eArg2.getValue(iDataType);
			}

			switch (iType) 
			{

				case ADD:
					return Column.add(a, b, iDataType);

				case SUBTRACT:
					return Column.subtract(a, b, iDataType);

				case MULTIPLY:
					return Column.multiply(a, b, iDataType);

				case DIVIDE:
					return Column.divide(a, b, iDataType);

				case CONCAT:
					return Column.concat(a, b);

				case IFNULL:
					return a == null ? b : a;

				default:

					// must be comparisation
					// todo: make sure it is
					return test();
			}
		}

		/**
		 * Method declaration
		 *
		 *
		 * @param o
		 * @param datatype
		 *
		 * @return
		 *
		 * @throws Exception
		 */
		private bool testValueList(object o,
			int datatype) 
		{
			if (iType == VALUELIST) 
			{
				if (datatype != iDataType) 
				{
					o = Column.convertobject(o, iDataType);
				}

				return hList.ContainsKey(o);
			} 
			else if (iType == QUERY) 
			{

				// todo: convert to valuelist before if everything is resolvable
				Result r = sSelect.getResult(0);
				Record n = r.rRoot;
				int    type = r.iType[0];

				if (datatype != type) 
				{
					o = Column.convertobject(o, type);
				}

				while (n != null) 
				{
					object o2 = n.data[0];

					if (o2 != null && o2.Equals(o)) 
					{
						return true;
					}

					n = n.next;
				}

				return false;
			}

			throw Trace.error(Trace.WRONG_DATA_TYPE);
		}

		/**
		 * Method declaration
		 *
		 *
		 * @return
		 *
		 * @throws Exception
		 */
		public bool test() 
		{
			switch (iType) 
			{

				case TRUE:
					return true;

				case NOT:
					Trace.assert(eArg2 == null, "Expression.test");

					return !eArg.test();

				case AND:
					return eArg.test() && eArg2.test();

				case OR:
					return eArg.test() || eArg2.test();

				case LIKE:

					// todo: now for all tests a new 'like' object required!
					string s = (string) eArg2.getValue(Column.VARCHAR);
					int    type = eArg.iDataType;
					Like   l = new Like(s, cLikeEscape,	type == Column.VARCHAR_IGNORECASE);
					string c = (string) eArg.getValue(Column.VARCHAR);

					return l.compare(c);

				case IN:
					return eArg2.testValueList(eArg.getValue(), eArg.iDataType);

				case EXISTS:
					Result r = eArg.sSelect.getResult(1);    // 1 is already enough

					return r.rRoot != null;
			}

			Trace.check(eArg != null, Trace.GENERAL_ERROR);

			object o = eArg.getValue();
			int    dtype = eArg.iDataType;

			Trace.check(eArg2 != null, Trace.GENERAL_ERROR);

			object o2 = eArg2.getValue(dtype);
			int    result = Column.compare(o, o2, dtype);

			switch (iType) 
			{

				case EQUAL:
					return result == 0;

				case BIGGER:
					return result > 0;

				case BIGGER_EQUAL:
					return result >= 0;

				case SMALLER_EQUAL:
					return result <= 0;

				case SMALLER:
					return result < 0;

				case NOT_EQUAL:
					return result != 0;
			}

			Trace.assert(false, "Expression.test2");

			return false;
		}

	}
}