\r
using System.Collections;\r
\r
-namespace System.Data \r
+namespace System.Data\r
{\r
/// <summary>\r
/// The main element which includes whole expression\r
/// </summary>\r
- internal class ExpressionMainElement : ExpressionElement \r
+ internal class ExpressionMainElement : ExpressionElement\r
{\r
\r
\r
\r
- public ExpressionMainElement (string s) \r
+ public ExpressionMainElement (string s)\r
{\r
s = ExpressionElement.ValidateExpression (s);\r
ParseExpression (s);\r
/// <summary>\r
/// Class for =\r
/// </summary>\r
- internal class ExpressionEquals : ExpressionElement \r
+ internal class ExpressionEquals : ExpressionElement\r
{ \r
\r
public ExpressionEquals (string exp1, string exp2) \r
/// <summary>\r
/// Class for <\r
/// </summary>\r
- internal class ExpressionLessThan : ExpressionElement \r
+ internal class ExpressionLessThan : ExpressionElement\r
{ \r
\r
public ExpressionLessThan (string exp1, string exp2) \r
/// <summary>\r
/// Class for <=\r
/// </summary>\r
- internal class ExpressionLessThanOrEqual : ExpressionElement \r
+ internal class ExpressionLessThanOrEqual : ExpressionElement\r
{ \r
\r
public ExpressionLessThanOrEqual (string exp1, string exp2) \r
/// <summary>\r
/// Class for >\r
/// </summary>\r
- internal class ExpressionGreaterThan : ExpressionElement \r
+ internal class ExpressionGreaterThan : ExpressionElement\r
{ \r
\r
public ExpressionGreaterThan (string exp1, string exp2) \r
/// <summary>\r
/// Class for >=\r
/// </summary>\r
- internal class ExpressionGreaterThanOrEqual : ExpressionElement \r
+ internal class ExpressionGreaterThanOrEqual : ExpressionElement\r
{ \r
\r
public ExpressionGreaterThanOrEqual (string exp1, string exp2) \r
/// <summary>\r
/// Class for <>\r
/// </summary>\r
- internal class ExpressionUnequals : ExpressionElement \r
+ internal class ExpressionUnequals : ExpressionElement\r
{ \r
\r
public ExpressionUnequals (string exp1, string exp2) \r
/// <summary>\r
/// Class for LIKE-operator\r
/// </summary>\r
- internal class ExpressionLike : ExpressionElement \r
+ internal class ExpressionLike : ExpressionElement\r
{ \r
\r
public ExpressionLike (string exp1, string exp2) \r
/// <summary>\r
/// Class for OR\r
/// </summary>\r
- internal class ExpressionOr : ExpressionElement \r
+ internal class ExpressionOr : ExpressionElement\r
{ \r
- public ExpressionOr (string exp1, string exp2) \r
+ public ExpressionOr (string exp1, string exp2)\r
{\r
ParseExpression (exp1);\r
ParseExpression (exp2);\r
/// <summary>\r
/// Class for AND\r
/// </summary>\r
- internal class ExpressionAnd : ExpressionElement \r
+ internal class ExpressionAnd : ExpressionElement\r
{ \r
- public ExpressionAnd (string exp1, string exp2) \r
+ public ExpressionAnd (string exp1, string exp2)\r
{\r
ParseExpression (exp1);\r
ParseExpression (exp2);\r
/// <summary>\r
/// Class for +\r
/// </summary>\r
- internal class ExpressionAddition : ExpressionElement \r
+ internal class ExpressionAddition : ExpressionElement\r
{\r
- public ExpressionAddition (string exp1, string exp2) \r
+ public ExpressionAddition (string exp1, string exp2)\r
{ \r
this.exp1 = exp1;\r
this.exp2 = exp2;\r
ParseExpression (exp2);\r
}\r
\r
- public override Type ResultType (DataRow Row) \r
+ public override Type ResultType (DataRow Row)\r
{\r
Type ResultType = typeof (string);\r
ExpressionElement exp1Temp = ((ExpressionElement)Elements [0]);\r
\r
\r
// This method is shouldnt never invoked\r
- public override bool Test (DataRow Row) \r
+ public override bool Test (DataRow Row)\r
{\r
throw new EvaluateException ();\r
}\r
/// <summary>\r
/// Class for -\r
/// </summary>\r
- internal class ExpressionSubtraction : ExpressionElement \r
+ internal class ExpressionSubtraction : ExpressionElement\r
{\r
- public ExpressionSubtraction (string exp1, string exp2) \r
+ public ExpressionSubtraction (string exp1, string exp2)\r
{ \r
this.exp1 = exp1;\r
this.exp2 = exp2;\r
}\r
\r
// This method is shouldnt never invoked\r
- public override bool Test (DataRow Row) \r
+ public override bool Test (DataRow Row)\r
{\r
throw new EvaluateException ();\r
}\r
/// <summary>\r
/// Class for *\r
/// </summary>\r
- internal class ExpressionMultiply : ExpressionElement \r
+ internal class ExpressionMultiply : ExpressionElement\r
{\r
- public ExpressionMultiply (string exp1, string exp2) \r
+ public ExpressionMultiply (string exp1, string exp2)\r
{ \r
this.exp1 = exp1;\r
this.exp2 = exp2;\r
ParseExpression (exp2);\r
}\r
\r
- public override Type ResultType (DataRow Row) \r
+ public override Type ResultType (DataRow Row)\r
{\r
Type ResultType = null;\r
ExpressionElement E1 = ((ExpressionElement)Elements [0]);\r
return CalculateResult (Row);\r
}\r
\r
- public override bool Test (DataRow Row) \r
+ public override bool Test (DataRow Row)\r
{\r
throw new EvaluateException ();\r
}\r
/// <summary>\r
/// Class for *\r
/// </summary>\r
- internal class ExpressionDivide : ExpressionElement \r
+ internal class ExpressionDivide : ExpressionElement\r
{\r
- public ExpressionDivide (string exp1, string exp2) \r
+ public ExpressionDivide (string exp1, string exp2)\r
{ \r
this.exp1 = exp1;\r
this.exp2 = exp2;\r
}\r
\r
// This method is shouldnt never invoked\r
- public override bool Test (DataRow Row) \r
+ public override bool Test (DataRow Row)\r
{\r
throw new EvaluateException ();\r
}\r
/// <summary>\r
/// Class for *\r
/// </summary>\r
- internal class ExpressionModulus : ExpressionElement \r
+ internal class ExpressionModulus : ExpressionElement\r
{\r
- public ExpressionModulus (string exp1, string exp2) \r
+ public ExpressionModulus (string exp1, string exp2)\r
{ \r
this.exp1 = exp1;\r
this.exp2 = exp2;\r
}\r
\r
// This method is shouldnt never invoked\r
- public override bool Test (DataRow Row) \r
+ public override bool Test (DataRow Row)\r
{\r
throw new EvaluateException ();\r
}\r
// _____A_G_G_R_E_G_A_T_E_S_____\r
//\r
\r
- internal class ExpressionAggregate : ExpressionElement \r
+ internal class ExpressionAggregate : ExpressionElement\r
{\r
\r
- public ExpressionAggregate() \r
+ public ExpressionAggregate()\r
{\r
}\r
\r
- public ExpressionAggregate(string s) \r
+ public ExpressionAggregate(string s)\r
{\r
s = ExpressionElement.ValidateExpression (s);\r
ParseExpression (s);\r
}\r
\r
\r
- public override bool Test (DataRow Row) \r
+ public override bool Test (DataRow Row)\r
{\r
throw new EvaluateException ();\r
}\r
\r
- public override object Result(DataRow Row) \r
+ public override object Result(DataRow Row)\r
{\r
DataRow[] rows = new DataRow[Row.Table.Rows.Count];\r
Row.Table.Rows.CopyTo(rows, 0);\r
return ((ExpressionAggregate)Elements[0]).Result(rows);\r
}\r
\r
- public virtual object Result(DataRow[] rows) \r
+ public virtual object Result(DataRow[] rows)\r
{\r
return ((ExpressionAggregate)Elements[0]).Result(rows);\r
}\r
\r
\r
- protected virtual void ParseParameters (string s) \r
+ protected virtual void ParseParameters (string s)\r
{\r
string stemp = s.ToLower ();\r
bool inString = false;\r
parentheses--;\r
\r
if ((s [i] == ',' || s [i] == ')') && !inString && parentheses == -1) \r
- { \r
- // Parameter changed\r
+ { // Parameter changed\r
\r
if (p1 == null) \r
{\r
/// <summary>\r
/// Class for Sum (column_Name)\r
/// </summary\r
- internal class ExpressionSum : ExpressionAggregate \r
+ internal class ExpressionSum : ExpressionAggregate\r
{\r
- public ExpressionSum (string exp1) \r
+ public ExpressionSum (string exp1)\r
{\r
ParseParameters (exp1);\r
}\r
\r
- public override object Result(DataRow[] rows) \r
+ public override object Result(DataRow[] rows)\r
{\r
ExpressionElement E1 = (ExpressionElement)Elements [0];\r
object value1 = E1.Result (rows[0]);\r
/// <summary>\r
/// Class for Avg (column_Name)\r
/// </summary\r
- internal class ExpressionAvg : ExpressionAggregate \r
+ internal class ExpressionAvg : ExpressionAggregate\r
{\r
- public ExpressionAvg (string exp1) \r
+ public ExpressionAvg (string exp1)\r
{\r
ParseParameters (exp1);\r
}\r
\r
- public override object Result(DataRow[] rows) \r
+ public override object Result(DataRow[] rows)\r
{\r
ExpressionElement E1 = (ExpressionElement)Elements [0];\r
object value1 = E1.Result (rows[0]);\r
/// <summary>\r
/// This is used from ExpressionStdDev for evaluating avg.\r
/// </summary>\r
- public ExpressionAvg (ExpressionElement E) \r
+ public ExpressionAvg (ExpressionElement E)\r
{\r
Elements.Add (E);\r
}\r
/// <summary>\r
/// Class for Min (column_Name)\r
/// </summary\r
- internal class ExpressionMin : ExpressionAggregate \r
+ internal class ExpressionMin : ExpressionAggregate\r
{\r
- public ExpressionMin (string exp1) \r
+ public ExpressionMin (string exp1)\r
{\r
ParseParameters (exp1);\r
}\r
\r
- public override object Result(DataRow[] rows) \r
+ public override object Result(DataRow[] rows)\r
{\r
ExpressionElement E1 = (ExpressionElement)Elements [0];\r
object value1 = E1.Result (rows[0]);\r
\r
Type t1 = null;\r
// This should be optimized somehow\r
- for (int i = 0; i < rows.Length; i++) \r
+ for (int i = 0; i < rows.Length; i++)\r
{\r
\r
// TODO: other types and exceptions\r
/// <summary>\r
/// Class for Max (column_Name)\r
/// </summary\r
- internal class ExpressionMax : ExpressionAggregate \r
+ internal class ExpressionMax : ExpressionAggregate\r
{\r
- public ExpressionMax (string exp1) \r
+ public ExpressionMax (string exp1)\r
{\r
ParseParameters (exp1);\r
}\r
\r
- public override object Result(DataRow[] rows) \r
+ public override object Result(DataRow[] rows)\r
{\r
ExpressionElement E1 = (ExpressionElement)Elements [0];\r
object value1 = E1.Result (rows[0]);\r
/// <summary>\r
/// Class for count (column)\r
/// </summary>\r
- internal class ExpressionCount : ExpressionAggregate \r
+ internal class ExpressionCount : ExpressionAggregate\r
{\r
- public ExpressionCount (string exp1) \r
+ public ExpressionCount (string exp1)\r
{\r
ParseParameters (exp1);\r
}\r
\r
- public override object Result(DataRow[] rows) \r
+ public override object Result(DataRow[] rows)\r
{\r
ExpressionElement E1 = (ExpressionElement)Elements [0];\r
int count = 0;\r
/// <summary>\r
/// Class for StdDev (column)\r
/// </summary>\r
- internal class ExpressionStdev : ExpressionAggregate \r
+ internal class ExpressionStdev : ExpressionAggregate\r
{\r
- public ExpressionStdev (string exp1) \r
+ public ExpressionStdev (string exp1)\r
{ \r
ParseParameters (exp1);\r
}\r
\r
- public override object Result(DataRow[] rows) \r
+ public override object Result(DataRow[] rows)\r
{\r
ExpressionElement E1 = (ExpressionElement)Elements [0];\r
ExpressionAvg Avg = new ExpressionAvg (E1);\r
if (E1 is ExpressionSingleElement) \r
{\r
\r
- for (int i = 0; i <rows.Length; i++) \r
+ for (int i = 0; i <rows.Length; i++)\r
{\r
// (value - avg)²\r
object v = E1.Result (rows[i]);\r
/// <summary>\r
/// Class for Var (column)\r
/// </summary>\r
- internal class ExpressionVar : ExpressionAggregate \r
+ internal class ExpressionVar : ExpressionAggregate\r
{\r
- public ExpressionVar (string exp1) \r
+ public ExpressionVar (string exp1)\r
{\r
ParseParameters (exp1);\r
}\r
\r
- public override object Result(DataRow[] rows) \r
+ public override object Result(DataRow[] rows)\r
{\r
ExpressionElement E1 = (ExpressionElement)Elements [0];\r
ExpressionAvg Avg = new ExpressionAvg (E1);\r
if (E1 is ExpressionSingleElement) \r
{\r
\r
- for (int i = 0; i < rows.Length; i++) \r
+ for (int i = 0; i < rows.Length; i++)\r
{\r
\r
\r
/// <summary>\r
/// Class for len (string) function\r
/// </summary>\r
- internal class ExpressionLen : ExpressionElement \r
+ internal class ExpressionLen : ExpressionElement\r
{\r
- public ExpressionLen (string exp1) \r
+ public ExpressionLen (string exp1)\r
{ \r
_ResultType = typeof (int);\r
ParseParameters (exp1);\r
return value1.ToString ().Length;\r
}\r
\r
- public override bool Test (DataRow Row) \r
+ public override bool Test (DataRow Row)\r
{\r
throw new EvaluateException ();\r
}\r
\r
- public void ParseParameters (string s) \r
+ public void ParseParameters (string s)\r
{\r
string stemp = s.ToLower ();\r
bool inString = false;\r
parentheses--;\r
\r
if ((s [i] == ',' || s [i] == ')') && !inString && parentheses == -1) \r
- { \r
- // Parameter changed\r
+ { // Parameter changed\r
\r
if (p1 == null) \r
{\r
/// <summary>\r
/// Class for iif (exp1, truepart, falsepart) function\r
/// </summary>\r
- internal class ExpressionIif : ExpressionElement \r
+ internal class ExpressionIif : ExpressionElement\r
{\r
- public ExpressionIif (string exp) \r
+ public ExpressionIif (string exp)\r
{ \r
ParseParameters (exp);\r
}\r
}\r
\r
// This method is shouldnt never invoked\r
- public override bool Test (DataRow Row) \r
+ public override bool Test (DataRow Row)\r
{\r
throw new EvaluateException ();\r
}\r
\r
- public override Type ResultType (DataRow Row) \r
+ public override Type ResultType (DataRow Row)\r
{ \r
ExpressionElement E1 = ((ExpressionElement)Elements [0]);\r
ExpressionElement E2 = ((ExpressionElement)Elements [1]);\r
/// <summary>\r
/// Parses expressions in parameters (exp, truepart, falsepart)\r
/// </summary>\r
- private void ParseParameters (string s) \r
+ private void ParseParameters (string s)\r
{\r
bool inString = false;\r
string stemp = s.ToLower ();\r
\r
if ((s [i] == ',' && !inString && parentheses == 0) || \r
(s [i] == ')' && i == (s.Length -1))) \r
- { \r
- // Parameter changed\r
+ { // Parameter changed\r
\r
if (p1 == null) \r
{\r
/// <summary>\r
/// Class for isnull (expression, returnvalue) function\r
/// </summary>\r
- internal class ExpressionIsNull : ExpressionElement \r
+ internal class ExpressionIsNull : ExpressionElement\r
{\r
- public ExpressionIsNull (string exp) \r
+ public ExpressionIsNull (string exp)\r
{ \r
ParseParameters (exp);\r
}\r
return R1;\r
}\r
\r
- public override Type ResultType (DataRow Row) \r
+ public override Type ResultType (DataRow Row)\r
{\r
ExpressionElement E1 = (ExpressionElement)Elements [0];\r
ExpressionElement E2 = (ExpressionElement)Elements [1];\r
/// <summary>\r
/// IsNull function does not return boolean value, so throw exception\r
/// </summary>\r
- public override bool Test (DataRow Row) \r
+ public override bool Test (DataRow Row)\r
{\r
throw new EvaluateException ();\r
}\r
/// <summary>\r
/// Parses parameters of function and invoke ParseExpression methods\r
/// </summary>\r
- private void ParseParameters (string s) \r
+ private void ParseParameters (string s)\r
{\r
bool inString = false;\r
string stemp = s.ToLower ();\r
\r
if ((s [i] == ',' && !inString && parentheses == 0) || \r
(s [i] == ')' && i == (s.Length -1))) \r
- { \r
- // Parameter changed\r
+ { // Parameter changed\r
\r
if (p1 == null) \r
{\r
/// <summary>\r
/// Class for Substring (expression, start, length) function\r
/// </summary>\r
- internal class ExpressionSubstring : ExpressionElement \r
+ internal class ExpressionSubstring : ExpressionElement\r
{\r
- public ExpressionSubstring (string exp) \r
+ public ExpressionSubstring (string exp)\r
{ \r
ParseParameters (exp);\r
_ResultType = typeof (string);\r
/// <summary>\r
/// IsNull function does not return boolean value, so throw exception\r
/// </summary>\r
- public override bool Test (DataRow Row) \r
+ public override bool Test (DataRow Row)\r
{\r
throw new EvaluateException ();\r
}\r
/// <summary>\r
/// Parses parameters of function and invoke ParseExpression methods\r
/// </summary>\r
- private void ParseParameters (string s) \r
+ private void ParseParameters (string s)\r
{\r
bool inString = false;\r
string stemp = s.ToLower ();\r
\r
if ((s [i] == ',' && !inString && parentheses == 0) || \r
(s [i] == ')' && i == (s.Length -1))) \r
- { \r
- // Parameter changed\r
+ { // Parameter changed\r
\r
if (p1 == null) \r
{\r
/// <summary>\r
/// Class for In (exp, exp, exp, ...) function\r
/// </summary>\r
- internal class ExpressionIn : ExpressionElement \r
+ internal class ExpressionIn : ExpressionElement\r
{\r
- public ExpressionIn (string exp1, string exp2) \r
+ public ExpressionIn (string exp1, string exp2)\r
{ \r
ParseExpression(exp1);\r
ParseParameters (exp2);\r
ExpressionElement E;\r
ExpressionElement columnElement = (ExpressionElement)Elements [0];\r
\r
- for (int i = 1; i < Elements.Count; i++) \r
+ for (int i = 1; i < Elements.Count; i++)\r
{\r
E = (ExpressionElement)Elements [i];\r
if(ExpressionElement.Compare (columnElement, E, Row) == 0)\r
/// <summary>\r
/// Parses parameters of function and invoke ParseExpression methods\r
/// </summary>\r
- private void ParseParameters (string s) \r
+ private void ParseParameters (string s)\r
{\r
bool inString = false;\r
ArrayList parameters = new ArrayList();\r
/// <summary>\r
/// Class for just one element for example string, int, ...\r
/// </summary>\r
- internal class ExpressionSingleElement : ExpressionElement \r
+ internal class ExpressionSingleElement : ExpressionElement\r
{ \r
private object Element = null;\r
\r
- public ExpressionSingleElement (string s) \r
+ public ExpressionSingleElement (string s)\r
{\r
// TODO: Every type should be checked\r
if (s.StartsWith ("'") && s.EndsWith ("'")) \r
} \r
}\r
\r
- public override object Result (DataRow Row) \r
+ public override object Result (DataRow Row)\r
{\r
object Result = null;\r
if (ResultType (Row) == typeof (DataColumn)) \r
\r
if (!Row.Table.Columns.Contains (Element.ToString ()))\r
throw new EvaluateException ("Column name '" + Element.ToString () + "' not found.");\r
- else \r
+ else\r
{\r
DataRowVersion rowVersion = DataRowVersion.Default;\r
// if this row is deleted we get the original version, or else we get an exception.\r
return Result;\r
}\r
\r
- public override bool Test (DataRow Row) \r
+ public override bool Test (DataRow Row)\r
{\r
throw new EvaluateException ();\r
} \r
/// <summary>\r
/// Parent class of all the elements of expression\r
/// </summary>\r
- internal abstract class ExpressionElement \r
+ internal abstract class ExpressionElement\r
{ \r
enum OP {OPERATOR, OPERAND};\r
enum OPERATOR_TYPE {SYMBOLIC, LITERAL, UNDEFINED};\r
\r
public virtual object Result (DataRow Row) {return null;}\r
\r
- public virtual Type ResultType (DataRow Row) \r
+ public virtual Type ResultType (DataRow Row)\r
{\r
return _ResultType;\r
}\r
\r
- protected object CalculateResult (DataRow Row) \r
+ protected object CalculateResult (DataRow Row)\r
{\r
ExpressionElement E1 = ((ExpressionElement)Elements [0]);\r
ExpressionElement E2 = ((ExpressionElement)Elements [1]);\r
\r
return Result; \r
}\r
- protected virtual object Calculate (object value1, object value2, Type TempType) \r
+ protected virtual object Calculate (object value1, object value2, Type TempType)\r
{\r
return null;\r
}\r
/// static method for comparing two ExpressionElement. This is used in =, <, >, <>, <=, >= elements.\r
/// If elements are equal returns 0, if E1 is less that E2, return -1 else if E1 is greater 1 \r
/// </summary>\r
- protected static int Compare (ExpressionElement E1, ExpressionElement E2, DataRow Row) \r
+ protected static int Compare (ExpressionElement E1, ExpressionElement E2, DataRow Row)\r
{ \r
int ReturnValue = 0;\r
\r
/// Checks syntax of expression and throws exception if needed.\r
/// Also removes whitespaces between operator elements for example: age < = 64 --> age <= 64\r
/// </summary>\r
- internal static string ValidateExpression (string s) \r
+ internal static string ValidateExpression (string s)\r
{ \r
//\r
// TODO: find out nice way to do this. This is NOT nice way :-P\r
}\r
else if (operatorType == OPERATOR_TYPE.SYMBOLIC) \r
{\r
+ \r
+ //Checking for operators following one another\r
+ if ((strOperator == " +" || strOperator == " -" || strOperator == " %" || strOperator ==" *") &&\r
+ (c == '=' || c== '<' || c== '>'))\r
+ throw new SyntaxErrorException (\r
+ "The operator " + strOperator + c + " is not valid");\r
\r
- if (c != '<' && c != '=' && c != '>' && c != ' ') \r
- {\r
- \r
- // this is COPY-PASTE\r
- op = OP.OPERAND;\r
- if (!newExp.EndsWith (" ") && !strOperator.StartsWith (" ")) \r
- strOperator = " " + strOperator;\r
+ // this is COPY-PASTE\r
+ op = OP.OPERAND;\r
+ if (!newExp.EndsWith (" ") && !strOperator.StartsWith (" ")) \r
+ strOperator = " " + strOperator;\r
\r
- newExp += strOperator;\r
+ newExp += strOperator;\r
\r
- if (Char.IsDigit (c))\r
- isDigit = true;\r
- \r
- strOperand = c.ToString ();\r
+ if (Char.IsDigit (c))\r
+ isDigit = true;\r
\r
- strOperator = "";\r
- continue;\r
- }\r
+ strOperand = c.ToString ();\r
+ \r
+ strOperator = "";\r
+ continue;\r
+\r
}\r
\r
if (operatorType == OPERATOR_TYPE.LITERAL && c == ' ') \r
/// Finds and creates Expression elements.\r
/// This presumes that expression is valid.\r
/// </summary>\r
- protected void ParseExpression (string s) \r
+ protected void ParseExpression (string s)\r
{ \r
//\r
// TODO/FIXME: IMHO, this should be done with different kind of parsing:\r
// These methods are temporary for now\r
//\r
\r
- private bool FindOrElement (string s, ref string s1, ref string s2) \r
+ private bool FindOrElement (string s, ref string s1, ref string s2)\r
{\r
string stemp = s.ToLower ();\r
int indexOf = stemp.IndexOf("or");\r
return false;\r
}\r
\r
- private bool FindAndElement (string s, ref string s1, ref string s2) \r
+ private bool FindAndElement (string s, ref string s1, ref string s2)\r
{\r
string stemp = s.ToLower ();\r
int indexOf = stemp.IndexOf("and");\r
return false;\r
}\r
\r
- private bool FindLikeElement (string s, ref string s1, ref string s2) \r
+ private bool FindLikeElement (string s, ref string s1, ref string s2)\r
{\r
string stemp = s.ToLower ();\r
int indexOf = stemp.IndexOf("like");\r
return false;\r
}\r
\r
- private bool FindEqualElement (string s, ref string s1, ref string s2) \r
+ private bool FindEqualElement (string s, ref string s1, ref string s2)\r
{\r
string stemp = s.ToLower ();\r
int indexOf = stemp.IndexOf ("=");\r
return false;\r
}\r
\r
- private bool FindUnequalElement (string s, ref string s1, ref string s2) \r
+ private bool FindUnequalElement (string s, ref string s1, ref string s2)\r
{\r
string stemp = s.ToLower ();\r
int indexOf = stemp.IndexOf ("<>");\r
}\r
\r
\r
- private bool FindLessThanElement (string s, ref string s1, ref string s2) \r
+ private bool FindLessThanElement (string s, ref string s1, ref string s2)\r
{\r
string stemp = s.ToLower ();\r
int indexOf = stemp.IndexOf ("<");\r
return false; \r
}\r
\r
- private bool FindLessThanOrEqualElement (string s, ref string s1, ref string s2) \r
+ private bool FindLessThanOrEqualElement (string s, ref string s1, ref string s2)\r
{\r
string stemp = s.ToLower ();\r
int indexOf = stemp.IndexOf ("<=");\r
return false; \r
}\r
\r
- private bool FindGreaterThanElement (string s, ref string s1, ref string s2) \r
+ private bool FindGreaterThanElement (string s, ref string s1, ref string s2)\r
{\r
string stemp = s.ToLower ();\r
int indexOf = stemp.IndexOf (">");\r
return false; \r
}\r
\r
- private bool FindGreaterThanOrEqualElement (string s, ref string s1, ref string s2) \r
+ private bool FindGreaterThanOrEqualElement (string s, ref string s1, ref string s2)\r
{\r
string stemp = s.ToLower ();\r
int indexOf = stemp.IndexOf (">=");\r
return false; \r
}\r
\r
- private bool FindAdditionElement (string s, ref string s1, ref string s2) \r
+ private bool FindAdditionElement (string s, ref string s1, ref string s2)\r
{\r
string stemp = s.ToLower ();\r
int indexOf = stemp.IndexOf ("+");\r
return false; \r
}\r
\r
- private bool FindSubtractElement (string s, ref string s1, ref string s2) \r
+ private bool FindSubtractElement (string s, ref string s1, ref string s2)\r
{\r
string stemp = s.ToLower ();\r
int indexOf = stemp.IndexOf ("-");\r
return false; \r
}\r
\r
- private bool FindMultiplyElement (string s, ref string s1, ref string s2) \r
+ private bool FindMultiplyElement (string s, ref string s1, ref string s2)\r
{\r
string stemp = s.ToLower ();\r
int indexOf = stemp.IndexOf ("*");\r
return false; \r
}\r
\r
- private bool FindDivideElement (string s, ref string s1, ref string s2) \r
+ private bool FindDivideElement (string s, ref string s1, ref string s2)\r
{\r
string stemp = s.ToLower ();\r
int indexOf = stemp.IndexOf ("/");\r
return false; \r
}\r
\r
- private bool FindModulusElement (string s, ref string s1, ref string s2) \r
+ private bool FindModulusElement (string s, ref string s1, ref string s2)\r
{\r
string stemp = s.ToLower ();\r
int indexOf = stemp.IndexOf ("%");\r
return false; \r
}\r
\r
- private bool FindAggregateElement (string s, AGGREGATE aggregate) \r
+ private bool FindAggregateElement (string s, AGGREGATE aggregate)\r
{\r
string agg = null;\r
\r
\r
}\r
\r
- private bool FindSumElement (string s) \r
+ private bool FindSumElement (string s)\r
{\r
string stemp = s.ToLower ();\r
int indexOf = stemp.IndexOf ("sum");\r
return false; \r
}\r
\r
- private bool FindAvgElement (string s) \r
+ private bool FindAvgElement (string s)\r
{\r
string stemp = s.ToLower ();\r
int indexOf = stemp.IndexOf ("avg");\r
return false; \r
}\r
\r
- private bool FindMinElement (string s) \r
+ private bool FindMinElement (string s)\r
{\r
string stemp = s.ToLower ();\r
int indexOf = stemp.IndexOf ("min");\r
return false; \r
}\r
\r
- private bool FindMaxElement (string s) \r
+ private bool FindMaxElement (string s)\r
{\r
string stemp = s.ToLower ();\r
int indexOf = stemp.IndexOf ("max");\r
return false; \r
}\r
\r
- private bool FindCountElement (string s) \r
+ private bool FindCountElement (string s)\r
{\r
string stemp = s.ToLower ();\r
int indexOf = stemp.IndexOf ("count");\r
return false; \r
}\r
\r
- private bool FindStdevElement (string s) \r
+ private bool FindStdevElement (string s)\r
{\r
string stemp = s.ToLower ();\r
int indexOf = stemp.IndexOf ("stdev");\r
return false; \r
}\r
\r
- private bool FindVarElement (string s) \r
+ private bool FindVarElement (string s)\r
{\r
string stemp = s.ToLower ();\r
int indexOf = stemp.IndexOf ("var");\r
return false; \r
}\r
\r
- private bool FindLenElement (string s) \r
+ private bool FindLenElement (string s)\r
{\r
string stemp = s.ToLower ();\r
int indexOf = stemp.IndexOf ("len");\r
return false; \r
}\r
\r
- private bool FindIifElement (string s) \r
+ private bool FindIifElement (string s)\r
{\r
string stemp = s.ToLower ();\r
int indexOf = stemp.IndexOf ("iif");\r
return false; \r
}\r
\r
- private bool FindIsNullElement (string s) \r
+ private bool FindIsNullElement (string s)\r
{\r
string stemp = s.ToLower ();\r
int indexOf = stemp.IndexOf ("isnull");\r
return false; \r
}\r
\r
- private bool FindSubstringElement (string s) \r
+ private bool FindSubstringElement (string s)\r
{\r
string stemp = s.ToLower ();\r
int indexOf = stemp.IndexOf ("substring");\r
return false; \r
}\r
\r
- private bool FindInElement (string s, ref string s1, ref string s2) \r
+ private bool FindInElement (string s, ref string s1, ref string s2)\r
{\r
string stemp = s.ToLower ();\r
int indexOf = stemp.IndexOf ("in");\r
Elements.Add (new ExpressionOr (s1.Trim (), s2.Trim ()));\r
}\r
\r
- private void CreateAndElement (string s1, string s2, string inside) \r
+ private void CreateAndElement (string s1, string s2, string inside)\r
{\r
CheckParenthesis (inside, ref s1, ref s2);\r
Elements.Add (new ExpressionAnd (s1.Trim (), s2.Trim ()));\r
}\r
\r
- private void CreateLikeElement (string s1, string s2, string inside) \r
+ private void CreateLikeElement (string s1, string s2, string inside)\r
{\r
CheckParenthesis (inside, ref s1, ref s2);\r
Elements.Add (new ExpressionLike (s1.Trim (), s2.Trim ()));\r
}\r
\r
- private void CreateInElement (string s1, string s2, string inside) \r
+ private void CreateInElement (string s1, string s2, string inside)\r
{\r
CheckParenthesis (inside, ref s1, ref s2);\r
Elements.Add (new ExpressionIn (s1.Trim (), s2.Trim ()));\r
}\r
\r
- private void CreateEqualsElement (string s1, string s2, string inside) \r
+ private void CreateEqualsElement (string s1, string s2, string inside)\r
{\r
CheckParenthesis (inside, ref s1, ref s2);\r
Elements.Add (new ExpressionEquals (s1.Trim (), s2.Trim ())); \r
}\r
\r
- private void CreateUnequalsElement (string s1, string s2, string inside) \r
+ private void CreateUnequalsElement (string s1, string s2, string inside)\r
{\r
CheckParenthesis (inside, ref s1, ref s2);\r
Elements.Add (new ExpressionUnequals (s1.Trim (), s2.Trim ()));\r
}\r
\r
- private void CreateLessThanElement (string s1, string s2, string inside) \r
+ private void CreateLessThanElement (string s1, string s2, string inside)\r
{\r
CheckParenthesis (inside, ref s1, ref s2);\r
Elements.Add (new ExpressionLessThan (s1.Trim (), s2.Trim ()));\r
}\r
\r
- private void CreateLessThanOrEqualElement (string s1, string s2, string inside) \r
+ private void CreateLessThanOrEqualElement (string s1, string s2, string inside)\r
{\r
CheckParenthesis (inside, ref s1, ref s2);\r
Elements.Add (new ExpressionLessThanOrEqual (s1.Trim (), s2.Trim ()));\r
}\r
\r
- private void CreateGreaterThanElement (string s1, string s2, string inside) \r
+ private void CreateGreaterThanElement (string s1, string s2, string inside)\r
{\r
CheckParenthesis (inside, ref s1, ref s2);\r
Elements.Add (new ExpressionGreaterThan (s1.Trim (), s2.Trim ()));\r
}\r
\r
\r
- private void CreateGreaterThanOrEqualElement (string s1, string s2, string inside) \r
+ private void CreateGreaterThanOrEqualElement (string s1, string s2, string inside)\r
{\r
CheckParenthesis (inside, ref s1, ref s2);\r
Elements.Add (new ExpressionGreaterThanOrEqual (s1.Trim (), s2.Trim ()));\r
Elements.Add (new ExpressionAddition (s1.Trim (), s2.Trim ()));\r
}\r
\r
- private void CreateSubtractionElement (string s1, string s2, string inside) \r
+ private void CreateSubtractionElement (string s1, string s2, string inside)\r
{\r
CheckParenthesis (inside, ref s1, ref s2); \r
Elements.Add (new ExpressionSubtraction (s1.Trim (), s2.Trim ()));\r
}\r
\r
- private void CreateMultiplyElement (string s1, string s2, string inside) \r
+ private void CreateMultiplyElement (string s1, string s2, string inside)\r
{\r
CheckParenthesis (inside, ref s1, ref s2);\r
Elements.Add (new ExpressionMultiply (s1.Trim (), s2.Trim ()));\r
}\r
\r
- private void CreateDivideElement (string s1, string s2, string inside) \r
+ private void CreateDivideElement (string s1, string s2, string inside)\r
{\r
CheckParenthesis (inside, ref s1, ref s2);\r
Elements.Add (new ExpressionDivide (s1.Trim (), s2.Trim ()));\r
}\r
\r
- private void CreateModulusElement (string s1, string s2, string inside) \r
+ private void CreateModulusElement (string s1, string s2, string inside)\r
{\r
CheckParenthesis (inside, ref s1, ref s2);\r
Elements.Add (new ExpressionModulus (s1.Trim (), s2.Trim ()));\r
\r
#region Little helppers\r
\r
- private void CheckParenthesis (string inside, ref string s1, ref string s2) \r
+ private void CheckParenthesis (string inside, ref string s1, ref string s2)\r
{\r
if (s1 == string.Empty && inside != string.Empty)\r
s1 = inside;\r
/// <summary>\r
/// Checks is the element part of column table\r
/// </summary>\r
- private bool IsPartOfColumnName (string s, int indexOf) \r
+ private bool IsPartOfColumnName (string s, int indexOf)\r
{\r
for (int i = indexOf; i >= 0; i--) \r
{\r
/// <summary>\r
/// Checks are element part of function\r
/// </summary>\r
- private bool IsPartOfFunction (string s, int indexOf) \r
+ private bool IsPartOfFunction (string s, int indexOf)\r
{\r
\r
// \r
using System.Collections;
using System.Globalization;
-namespace System.Data {
+namespace System.Data \r
+{
- internal class XmlDataLoader
+ internal class XmlDataLoader
{
- private DataSet DSet;
+ private DataSet DSet;
Hashtable DiffGrRows = new Hashtable ();
- public XmlDataLoader (DataSet set)
+ public XmlDataLoader (DataSet set)
{
DSet = set;
}
{
XmlReadMode Result = XmlReadMode.Auto;
- switch (mode) {
+ switch (mode) \r
+ {
case XmlReadMode.Fragment:
break;
[MonoTODO]
private void ReadModeInferSchema (XmlReader reader)
{
- // root element is DataSets name
- reader.MoveToContent ();
-
- DSet.DataSetName = reader.LocalName;
-
- // And now comes tables
- while (reader.Read ()) {
-
- // skip possible inline-schema
- if (String.Compare (reader.LocalName, "schema", true) == 0 && reader.NodeType == XmlNodeType.Element) {
- while (reader.Read () && (reader.NodeType != XmlNodeType.EndElement
- || String.Compare (reader.LocalName, "schema", true) != 0));
- }
-
-
- if (reader.NodeType == XmlNodeType.Element) {
-
- string datatablename = reader.LocalName;
- DataTable table;
- bool NewTable = false;
-
- if (!DSet.Tables.Contains (datatablename)) {
- table = new DataTable (reader.LocalName);
- DSet.Tables.Add (table);
- NewTable = true;
- }
- else {
- table = DSet.Tables [datatablename];
- }
-
- Hashtable rowValue = new Hashtable ();
-
- while (reader.Read () && (reader.NodeType != XmlNodeType.EndElement
- || reader.LocalName != datatablename))
- {
- if (reader.NodeType == XmlNodeType.Element) {
-
- string dataColumnName = reader.LocalName;
- if (NewTable)
- table.Columns.Add (dataColumnName);
-
- // FIXME: exception?
- if (!reader.Read ())
- return;
-
- rowValue.Add (dataColumnName, reader.Value);
- }
- }
-
- DataRow row = table.NewRow ();
-
- IDictionaryEnumerator enumerator = rowValue.GetEnumerator ();
- while (enumerator.MoveNext ()) {
- row [enumerator.Key.ToString ()] = enumerator.Value.ToString ();
- }
-
- table.Rows.Add (row);
- }
- }
+ // first load an XmlDocument from the reader.
+ XmlDocument doc = new XmlDocument();
+ doc.Load(reader);
+
+ // set EnforceConstraint to false - we do not want any validation during
+ // load time.
+ bool origEnforceConstraint = DSet.EnforceConstraints;
+ DSet.EnforceConstraints = false;
+
+ // first element is the DataSet.
+ XmlElement elem = doc.DocumentElement;
+ DSet.DataSetName = elem.LocalName;
+
+ // get the Namespace of the DataSet.
+ if (elem.HasAttribute("xmlns"))
+ DSet.Namespace = elem.Attributes["xmlns"].Value;
+
+ // The childs are tables.
+ XmlNodeList nList = elem.ChildNodes;
+
+ for (int i = 0; i < nList.Count; i++)
+ {
+ XmlNode node = nList[i];
+ AddRowToTable(node, null);
+ }
+ // set the EnforceConstraints to original value;
+ DSet.EnforceConstraints = origEnforceConstraint;
}
// Read Xmldocument. XmlReadMode.ReadSchema and XmlReadMode.IgnoreSchema
reader.ReadStartElement ();
reader.MoveToContent ();
- while (reader.NodeType != XmlNodeType.EndElement)
+ while (reader.NodeType != XmlNodeType.EndElement) \r
{
- if (reader.NodeType == XmlNodeType.Element)
+ if (reader.NodeType == XmlNodeType.Element)\r
{
// FIXME: possible inline-schema should be readed here
if (String.Compare (reader.LocalName, "schema", true) == 0) \r
private void ReadColumns (XmlReader reader, DataRow row, DataTable table, string TableName)
{
- do {
- if (reader.NodeType == XmlNodeType.Element) {
+ do \r
+ {
+ if (reader.NodeType == XmlNodeType.Element) \r
+ {
DataColumn col = table.Columns [reader.LocalName];
- if (col != null) {
+ if (col != null) \r
+ {
reader.Read ();
row [col] = StringToObject (col.DataType, reader.Value);
}
}
- else {
+ else \r
+ {
reader.Read ();
}
} while (table.TableName != reader.LocalName
- || reader.NodeType != XmlNodeType.EndElement);
+ || reader.NodeType != XmlNodeType.EndElement);
}
internal static object StringToObject (Type type, string value)
{
if (type == null) return value;
- switch (Type.GetTypeCode (type))
+ switch (Type.GetTypeCode (type))\r
{
case TypeCode.Boolean: return XmlConvert.ToBoolean (value);
case TypeCode.Byte: return XmlConvert.ToByte (value);
return Convert.ChangeType (value, type);
}
+ private void AddRowToTable(XmlNode tableNode, DataColumn relationColumn)
+ {
+ Hashtable rowValue = new Hashtable();
+ DataTable table;
+
+ // Check if the table exists in the DataSet. If not create one.
+ if (DSet.Tables.Contains(tableNode.LocalName))
+ table = DSet.Tables[tableNode.LocalName];
+ else
+ {
+ table = new DataTable(tableNode.LocalName);
+ DSet.Tables.Add(table);
+ }
+
+ // Get the child nodes of the table. Any child can be one of the following tow:
+ // 1. DataTable - if there was a relation with another table..
+ // 2. DataColumn - column of the current table.
+ XmlNodeList childList = tableNode.ChildNodes;
+ for (int i = 0; i < childList.Count; i++)
+ {
+ XmlNode childNode = childList[i];
+
+ // The child node is a table if:
+ // 1. He has attributes it means that it is a table OR
+ // 2. He has more then one child nodes. Columns has only one child node
+ // which is a Text node type that has the column value.
+ if (childNode.ChildNodes.Count > 1 || childNode.Attributes.Count > 0)
+ {
+ // We need to create new column for the relation between the current
+ // table and the new table we found (the child table).
+ string newRelationColumnName = table.TableName + "_Id";
+ if (!table.Columns.Contains(newRelationColumnName))
+ {
+ DataColumn newRelationColumn = new DataColumn(newRelationColumnName, typeof(int));
+ newRelationColumn.AutoIncrement = true;
+ table.Columns.Add(newRelationColumn);
+ }
+ // Add a row to the new table we found.
+ AddRowToTable(childNode, table.Columns[newRelationColumnName]);
+ }
+ else //Child node is a column.
+ {
+ if (!table.Columns.Contains(childNode.LocalName))
+ table.Columns.Add(childNode.LocalName);
+
+ rowValue.Add(childNode.LocalName, childNode.FirstChild.Value);
+ }
+ }
+
+ // Column can be attribute of the table element.
+ XmlAttributeCollection aCollection = tableNode.Attributes;
+ for (int i = 0; i < aCollection.Count; i++)
+ {
+ XmlAttribute attr = aCollection[i];
+ //the atrribute can be the namespace.
+ if (attr.Prefix.Equals("xmlns"))
+ table.Namespace = attr.Value;
+ else // the attribute is a column.
+ {
+ if (!table.Columns.Contains(attr.LocalName))
+ table.Columns.Add(attr.LocalName);
+ table.Columns[attr.LocalName].Namespace = table.Namespace;
+
+ rowValue.Add(attr.LocalName, attr.Value);
+ }
+ }
+
+ // If the current table is a child table we need to add a new column for the relation
+ // and add a new relation to the DataSet.
+ if (relationColumn != null)
+ {
+ if (!table.Columns.Contains(relationColumn.ColumnName))
+ {
+ DataColumn dc = new DataColumn(relationColumn.ColumnName, typeof(int));
+ dc.AutoIncrement = true;
+ table.Columns.Add(dc);
+ DSet.Relations.Add(relationColumn, dc);
+ }
+ }
+
+ // Create new row and add all values to the row.
+ // then add it to the table.
+ DataRow row = table.NewRow ();
+
+ IDictionaryEnumerator enumerator = rowValue.GetEnumerator ();
+ while (enumerator.MoveNext ()) \r
+ {
+ row [enumerator.Key.ToString ()] = enumerator.Value.ToString ();
+ }
+
+ table.Rows.Add (row);
+
+ }
+
#endregion // Private helper methods
+
+
}
+
}
projects / mono.git / commitdiff