parser.cs

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

			}
		}

		/**
		 * Method declaration
		 *
		 *
		 * @param type
		 *
		 * @return
		 *
		 * @throws Exception
		 */
		private object getValue(int type) 
		{
			Expression r = parseExpression();

			r.resolve(null);

			return r.getValue(type);
		}

		/**
		 * Method declaration
		 *
		 *
		 * @return
		 *
		 * @throws Exception
		 */
		private Expression parseExpression() 
		{
			read();

			// todo: really this should be in readTerm
			// but then grouping is much more complex
			if (iToken == Expression.MIN || iToken == Expression.MAX
				|| iToken == Expression.COUNT || iToken == Expression.SUM
				|| iToken == Expression.AVG) 
			{
				int type = iToken;

				read();

				Expression r = new Expression(type, readOr(), null);

				tTokenizer.back();

				return r;
			}

			Expression rx = readOr();

			tTokenizer.back();

			return rx;
		}

		/**
		 * Method declaration
		 *
		 *
		 * @return
		 *
		 * @throws Exception
		 */
		private Expression readOr() 
		{
			Expression r = readAnd();

			while (iToken == Expression.OR) 
			{
				int	       type = iToken;
				Expression a = r;

				read();

				r = new Expression(type, a, readAnd());
			}

			return r;
		}

		/**
		 * Method declaration
		 *
		 *
		 * @return
		 *
		 * @throws Exception
		 */
		private Expression readAnd() 
		{
			Expression r = readCondition();

			while (iToken == Expression.AND) 
			{
				int	       type = iToken;
				Expression a = r;

				read();

				r = new Expression(type, a, readCondition());
			}

			return r;
		}

		/**
		 * Method declaration
		 *
		 *
		 * @return
		 *
		 * @throws Exception
		 */
		private Expression readCondition() 
		{
			if (iToken == Expression.NOT) 
			{
				int type = iToken;

				read();

				return new Expression(type, readCondition(), null);
			} 
			else if (iToken == Expression.EXISTS) 
			{
				int type = iToken;

				read();
				readThis(Expression.OPEN);
				Trace.check(iToken == Expression.SELECT, Trace.UNEXPECTED_TOKEN);

				Expression s = new Expression(parseSelect());

				read();
				readThis(Expression.CLOSE);

				return new Expression(type, s, null);
			} 
			else 
			{
				Expression a = readConcat();
				bool    not = false;

				if (iToken == Expression.NOT) 
				{
					not = true;

					read();
				}

				if (iToken == Expression.LIKE) 
				{
					read();

					Expression b = readConcat();
					char       escape = "0".ToChar();

					if (sToken.Equals("ESCAPE")) 
					{
						read();

						Expression c = readTerm();

						Trace.check(c.getType() == Expression.VALUE,
							Trace.INVALID_ESCAPE);

						string s = (string) c.getValue(Column.VARCHAR);

						if (s == null || s.Length < 1) 
						{
							throw Trace.error(Trace.INVALID_ESCAPE, s);
						}

						escape = s.Substring(0,1).ToChar();
					}

					a = new Expression(Expression.LIKE, a, b);

					a.setLikeEscape(escape);
				} 
				else if (iToken == Expression.BETWEEN) 
				{
					read();

					Expression l = new Expression(Expression.BIGGER_EQUAL, a,
						readConcat());

					readThis(Expression.AND);

					Expression h = new Expression(Expression.SMALLER_EQUAL, a,
						readConcat());

					a = new Expression(Expression.AND, l, h);
				} 
				else if (iToken == Expression.IN) 
				{
					int type = iToken;

					read();
					readThis(Expression.OPEN);

					Expression b = null;

					if (iToken == Expression.SELECT) 
					{
						b = new Expression(parseSelect());

						read();
					} 
					else 
					{
						tTokenizer.back();

						ArrayList v = new ArrayList();

						while (true) 
						{
							v.Add(getValue(Column.VARCHAR));
							read();

							if (iToken != Expression.COMMA) 
							{
								break;
							}
						}

						b = new Expression(v);
					}

					readThis(Expression.CLOSE);

					a = new Expression(type, a, b);
				} 
				else 
				{
					Trace.check(!not, Trace.UNEXPECTED_TOKEN);

					if (Expression.isCompare(iToken)) 
					{
						int type = iToken;

						read();

						return new Expression(type, a, readConcat());
					}

					return a;
				}

				if (not) 
				{
					a = new Expression(Expression.NOT, a, null);
				}

				return a;
			}
		}

		/**
		 * Method declaration
		 *
		 *
		 * @param type
		 *
		 * @throws Exception
		 */
		private void readThis(int type) 
		{
			Trace.check(iToken == type, Trace.UNEXPECTED_TOKEN);
			read();
		}

		/**
		 * Method declaration
		 *
		 *
		 * @return
		 *
		 * @throws Exception
		 */
		private Expression readConcat() 
		{
			Expression r = readSum();

			while (iToken == Expression.STRINGCONCAT) 
			{
				int	       type = Expression.CONCAT;
				Expression a = r;

				read();

				r = new Expression(type, a, readSum());
			}

			return r;
		}

		/**
		 * Method declaration
		 *
		 *
		 * @return
		 *
		 * @throws Exception
		 */
		private Expression readSum() 
		{
			Expression r = readFactor();

			while (true) 
			{
				int type;

				if (iToken == Expression.PLUS) 
				{
					type = Expression.ADD;
				} 
				else if (iToken == Expression.NEGATE) 
				{
					type = Expression.SUBTRACT;
				} 
				else 
				{
					break;
				}

				Expression a = r;

				read();

				r = new Expression(type, a, readFactor());
			}

			return r;
		}

		/**
		 * Method declaration
		 *
		 *
		 * @return
		 *
		 * @throws Exception
		 */
		private Expression readFactor() 
		{
			Expression r = readTerm();

			while (iToken == Expression.MULTIPLY || iToken == Expression.DIVIDE) 
			{
				int	       type = iToken;
				Expression a = r;

				read();

				r = new Expression(type, a, readTerm());
			}

			return r;
		}

		/**
		 * Method declaration
		 *
		 *
		 * @return
		 *
		 * @throws Exception
		 */
		private Expression readTerm() 
		{
			Expression r = null;

			if (iToken == Expression.COLUMN) 
			{
				string name = sToken;

				r = new Expression(sTable, sToken);

				read();

				/*				if (iToken == Expression.OPEN) 
								{
									Function f = new Function(dDatabase.getAlias(name), cChannel);
									int      len = f.getArgCount();
									int      i = 0;

									read();

									if (iToken != Expression.CLOSE) 
									{
										while (true) 
										{
											f.setArgument(i++, readOr());

											if (iToken != Expression.COMMA) 
											{
												break;
											}

											read();
										}
									}

									readThis(Expression.CLOSE);

									r = new Expression(f);
								} */
			}

			else if (iToken == Expression.NEGATE) 
			{
				int type = iToken;

				read();

				r = new Expression(type, readTerm(), null);
			} 
			else if (iToken == Expression.PLUS) 
			{
				read();

				r = readTerm();
			} 
			else if (iToken == Expression.OPEN) 
			{
				read();

				r = readOr();

				if (iToken != Expression.CLOSE) 
				{
					throw Trace.error(Trace.UNEXPECTED_TOKEN, sToken);
				}

				read();
			} 
			else if (iToken == Expression.VALUE) 
			{
				r = new Expression(iType, oData);

				read();
			} 
			else if (iToken == Expression.SELECT) 
			{
				r = new Expression(parseSelect());

				read();
			} 
			else if (iToken == Expression.MULTIPLY) 
			{
				r = new Expression(sTable, null);

				read();
			} 
			else if (iToken == Expression.IFNULL
				|| iToken == Expression.CONCAT) 
			{
				int type = iToken;

				read();
				readThis(Expression.OPEN);

				r = readOr();

				readThis(Expression.COMMA);

				r = new Expression(type, r, readOr());

				readThis(Expression.CLOSE);
			} 
			else if (iToken == Expression.CASEWHEN) 
			{
				int type = iToken;

				read();
				readThis(Expression.OPEN);

				r = readOr();

				readThis(Expression.COMMA);

				Expression thenelse = readOr();

				readThis(Expression.COMMA);

				// thenelse part is never evaluated; only init
				thenelse = new Expression(type, thenelse, readOr());
				r = new Expression(type, r, thenelse);

				readThis(Expression.CLOSE);
			} 
			else if (iToken == Expression.CONVERT) 
			{
				int type = iToken;

				read();
				readThis(Expression.OPEN);

				r = readOr();

				readThis(Expression.COMMA);

				int t = Column.getTypeNr(sToken);

				r = new Expression(type, r, null);

				r.setDataType(t);
				read();
				readThis(Expression.CLOSE);
			} 
			else if (iToken == Expression.CAST) 
			{
				read();
				readThis(Expression.OPEN);

				r = readOr();

				Trace.check(sToken.Equals("AS"), Trace.UNEXPECTED_TOKEN, sToken);
				read();

				int t = Column.getTypeNr(sToken);

				r = new Expression(Expression.CONVERT, r, null);

				r.setDataType(t);
				read();
				readThis(Expression.CLOSE);
			} 
			else 
			{
				throw Trace.error(Trace.UNEXPECTED_TOKEN, sToken);
			}

			return r;
		}

		/**
		 * Method declaration
		 *
		 *
		 * @throws Exception
		 */
		private void read() 
		{
			sToken = tTokenizer.getstring();

			if (tTokenizer.wasValue()) 
			{
				iToken = Expression.VALUE;
				oData = tTokenizer.getAsValue();
				iType = tTokenizer.getType();
			} 
			else if (tTokenizer.wasName()) 
			{
				iToken = Expression.COLUMN;
				sTable = null;
			} 
			else if (tTokenizer.wasLongName()) 
			{
				sTable = tTokenizer.getLongNameFirst();
				sToken = tTokenizer.getLongNameLast();

				if (sToken.Equals("*")) 
				{
					iToken = Expression.MULTIPLY;
				} 
				else 
				{
					iToken = Expression.COLUMN;
				}
			} 
			else if (sToken.Equals("")) 
			{
				iToken = Expression.END;
			} 
			else if (sToken.Equals("AND")) 
			{
				iToken = Expression.AND;
			} 
			else if (sToken.Equals("OR")) 
			{
				iToken = Expression.OR;
			} 
			else if (sToken.Equals("NOT")) 
			{
				iToken = Expression.NOT;
			} 
			else if (sToken.Equals("IN")) 
			{
				iToken = Expression.IN;
			} 
			else if (sToken.Equals("EXISTS")) 
			{
				iToken = Expression.EXISTS;
			} 
			else if (sToken.Equals("BETWEEN")) 
			{
				iToken = Expression.BETWEEN;
			} 
			else if (sToken.Equals("+")) 
			{
				iToken = Expression.PLUS;
			} 
			else if (sToken.Equals("-")) 
			{
				iToken = Expression.NEGATE;
			} 
			else if (sToken.Equals("*")) 
			{
				iToken = Expression.MULTIPLY;
				sTable = null;    // in case of ASTERIX
			} 
			else if (sToken.Equals("/")) 
			{
				iToken = Expression.DIVIDE;
			} 
			else if (sToken.Equals("||")) 
			{
				iToken = Expression.STRINGCONCAT;
			} 
			else if (sToken.Equals("(")) 
			{
				iToken = Expression.OPEN;
			} 
			else if (sToken.Equals(")")) 
			{
				iToken = Expression.CLOSE;
			} 
			else if (sToken.Equals("SELECT")) 
			{
				iToken = Expression.SELECT;
			} 
			else if (sToken.Equals("<")) 
			{
				iToken = Expression.SMALLER;
			} 
			else if (sToken.Equals("<=")) 
			{
				iToken = Expression.SMALLER_EQUAL;
			} 
			else if (sToken.Equals(">=")) 
			{
				iToken = Expression.BIGGER_EQUAL;
			} 
			else if (sToken.Equals(">")) 
			{
				iToken = Expression.BIGGER;
			} 
			else if (sToken.Equals("=")) 
			{
				iToken = Expression.EQUAL;
			} 
			else if (sToken.Equals("IS")) 
			{
				sToken = tTokenizer.getstring();

				if (sToken.Equals("NOT")) 
				{
					iToken = Expression.NOT_EQUAL;
				} 
				else 
				{
					iToken = Expression.EQUAL;

					tTokenizer.back();
				}
			} 
			else if (sToken.Equals("<>") || sToken.Equals("!=")) 
			{
				iToken = Expression.NOT_EQUAL;
			} 
			else if (sToken.Equals("LIKE")) 
			{
				iToken = Expression.LIKE;
			} 
			else if (sToken.Equals("COUNT")) 
			{
				iToken = Expression.COUNT;
			} 
			else if (sToken.Equals("SUM")) 
			{
				iToken = Expression.SUM;
			} 
			else if (sToken.Equals("MIN")) 
			{
				iToken = Expression.MIN;
			} 
			else if (sToken.Equals("MAX")) 
			{
				iToken = Expression.MAX;
			} 
			else if (sToken.Equals("AVG")) 
			{
				iToken = Expression.AVG;
			} 
			else if (sToken.Equals("IFNULL")) 
			{
				iToken = Expression.IFNULL;
			} 
			else if (sToken.Equals("CONVERT")) 
			{
				iToken = Expression.CONVERT;
			} 
			else if (sToken.Equals("CAST")) 
			{
				iToken = Expression.CAST;
			} 
			else if (sToken.Equals("CASEWHEN")) 
			{
				iToken = Expression.CASEWHEN;
			} 
			else if (sToken.Equals(",")) 
			{
				iToken = Expression.COMMA;
			} 
			else 
			{
				iToken = Expression.END;
			}
		}
	}
}