private static ProbRelation getRelationBySelectAttributeV2(ProbRelation probRelation, List <ProbAttribute> attributes)
{
ProbRelation relation = new ProbRelation();
relation.RelationName = probRelation.RelationName;
List <int> indexs = new List <int>();
List <int> indexRemove = new List <int>();
for (int i = 0; i < probRelation.Scheme.Attributes.Count; i++)
{
if (attributes.Any(x => x.AttributeName.Trim().ToLower().Contains(probRelation.Scheme.Attributes[i].AttributeName.Trim().ToLower())))
{
indexs.Add(i);
}
}
foreach (ProbTuple item in probRelation.tuples)
{
ProbTuple tuple = new ProbTuple();
for (int i = 0; i < indexs.Count; i++)
{
tuple.Triples.Add(item.Triples[indexs[i]]);
}
relation.tuples.Add(tuple);
}
relation.Scheme.Attributes = attributes;
return(relation);
}
public ProbTuple(ProbTuple tuple)
{
// TODO: Complete member initialization
this.Triples = new List <ProbTriple>();
foreach (ProbTriple item in tuple.Triples)
{
ProbTriple triple = new ProbTriple(item);
this.Triples.Add(triple);
}
}
private static void JoinTwoRelation(ProbRelation relation, ProbRelation relation1, ProbRelation relation2)
{
foreach (ProbTuple tupleOne in relation1.tuples)
{
foreach (ProbTuple tupleTwo in relation2.tuples)
{
ProbTuple value = new ProbTuple();
value.Triples.AddRange(tupleOne.Triples);
value.Triples.AddRange(tupleTwo.Triples);
relation.tuples.Add(value);
}
}
}
public bool Satisfied(ProbTuple tuple)
{
this.tuple = tuple;
string conditionStr = this.conditionString;
#region
int i = 0;
int j = 0;
while (i < conditionStr.Length - 1)
{
if (conditionStr[i] == '(')
{
j = i + 1;
while (j < conditionStr.Length)
{
if (conditionStr[j] == ']')
{
if (IsSelectionExpression(conditionStr.Substring(i, j - i + 1)))
{
string expValue = ExpressionValue(conditionStr.Substring(i, j - i + 1)) ? "1" : "0";
conditionStr = conditionStr.Insert(i, expValue);
conditionStr = conditionStr.Remove(i + 1, j - i + 1);
break;
}
if (MessageError != string.Empty)
{
return(false);
}
}
j++;
}
}
i++;
}
#endregion
conditionStr = conditionStr.Replace(" ", "").ToLower();
conditionStr = conditionStr.Replace("and", "&");
conditionStr = conditionStr.Replace("or", "|");
conditionStr = conditionStr.Replace("not", "!");
List <string> rpn = SC_PostfixNotation(conditionStr); // reverse to postfix notation
return(CalculateCondition(rpn));
}
public bool Satisfied(ProbTuple tuple)
{
this.tuple = tuple;
dictProb = new Dictionary <string, bool>();
dictCon = new Dictionary <string, bool>();
CalculateConditionProb();
CalculateConditionStr(subCondition);
var listConditionProb = GetArrayCondition(this.conditionString);
if (listConditionProb == null)
{
return(false);
}
return(CalculateTotalCondition(listConditionProb));
}
private ProbRelation Descartes()
{
ProbRelation relation = new ProbRelation();
relation.ListRenameRelation.Add(this.selectedRelations[0].RelationName);
foreach (ProbAttribute attr in this.selectedRelations[0].Scheme.Attributes)
{
if (attr.AttributeName.IndexOf(".") == -1)
{
attr.AttributeName = this.selectedRelations[0].RelationName + "." + attr.AttributeName;
}
}
relation.Scheme.Attributes.AddRange(this.selectedRelations[0].Scheme.Attributes);
relation.ListRenameRelation.Add(this.selectedRelations[1].RelationName);
foreach (ProbAttribute attr in this.selectedRelations[1].Scheme.Attributes)
{
if (attr.AttributeName.IndexOf(".") == -1)
{
attr.AttributeName = this.selectedRelations[1].RelationName + "." + attr.AttributeName;
}
}
relation.Scheme.Attributes.AddRange(this.selectedRelations[1].Scheme.Attributes);
foreach (ProbTuple tupleOne in this.selectedRelations[0].tuples)
{
foreach (ProbTuple tupleTwo in this.selectedRelations[1].tuples)
{
ProbTuple value = new ProbTuple();
value.Triples.AddRange(tupleOne.Triples);
value.Triples.AddRange(tupleTwo.Triples);
relation.tuples.Add(value);
}
}
return(relation);
}
private List <ProbRelation> GetAllRelation(string valueString)
{
int posOne;
int posTwo;
string relationsString = string.Empty;
List <string> listOfRelationName = this.probDatabase.ListOfRelationNameToLower();
string[] seperator = { "," };
string[] relations;
List <ProbRelation> probRelations = new List <ProbRelation>();
//////////////////////// Get Relations ///////////////////////
posOne = valueString.IndexOf("from") + 4;
if (!valueString.Contains("where"))
{
posTwo = valueString.Length - 1;
}
else
{
posTwo = valueString.IndexOf("where") - 1;
}
relationsString = valueString.Substring(posOne, posTwo - posOne + 1); // Get Relation in the Query Text
if (relationsString.Trim().Length <= 0)
{
MessageError = "No relation exists in the query !";
return(null);
}
if (relationsString.Contains(","))
{
relations = relationsString.Split(seperator, StringSplitOptions.RemoveEmptyEntries);
}
else
if (relationsString.Contains(" natural join in") || relationsString.Contains(" natural join ig") || relationsString.Contains(" natural join me"))
{
relations = new string[2];
if (relationsString.Contains(" natural join in"))
{
relations[0] = relationsString.Substring(0, relationsString.IndexOf("natural join in")).Trim();
relations[1] = relationsString.Substring(relationsString.IndexOf("natural join in") + 15).Trim();
OperationNaturalJoin = "in";
}
else
if (relationsString.Contains(" natural join ig"))
{
relations[0] = relationsString.Substring(0, relationsString.IndexOf("natural join ig")).Trim();
relations[1] = relationsString.Substring(relationsString.IndexOf("natural join ig") + 15).Trim();
OperationNaturalJoin = "ig";
OperationNaturalJoin = "ig";
}
else
{
relations[0] = relationsString.Substring(0, relationsString.IndexOf("natural join me")).Trim();
relations[1] = relationsString.Substring(relationsString.IndexOf("natural join me") + 15).Trim();
OperationNaturalJoin = "me";
}
foreach (string item in relations)
{
if (item == "")
{
MessageError = "Incorrect syntax near 'from'.";
return(null);
}
string[] listTmp = item.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (listTmp.Length != 1)
{
MessageError = "Incorrect syntax near 'from'.";
return(null);
}
}
flagNaturalJoin = true;
}
else
{
relations = new string[1];
relations[0] = relationsString;
}
if (relations.Length > 2)
{
MessageError = "The query only accept one or two relation.";
return(null);
}
if (relations.Length == 1)
{
string[] listTmp = relations[0].Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (listTmp.Length > 2)
{
MessageError = "Incorrect syntax near 'from'.";
return(null);
}
if (!listOfRelationName.Contains(listTmp[0].ToLower()))
{
MessageError = String.Format("Invalid relation name '{0}'.", listTmp[0]);
return(null);
}
}
else
{
for (int i = 0; i < relations.Length; i++)
{
string[] listTmp = relations[i].Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (listTmp.Length > 2)
{
MessageError = "Incorrect syntax near 'from'.";
return(null);
}
if (!listOfRelationName.Contains(listTmp[0].ToLower()))
{
MessageError = String.Format("Invalid relation name '{0}'.", listTmp[0]);
return(null);
}
}
}
for (int i = 0; i < relations.Length; i++)
{
string[] listTmp = relations[i].Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
ProbRelation tmp = this.probDatabase.Relations.SingleOrDefault(c => c.RelationName.ToLower().Equals(listTmp[0], StringComparison.OrdinalIgnoreCase));
ProbRelation rela = new ProbRelation();
if (listTmp.Length == 2)
{
rela.RelationName = listTmp[1];
}
else
{
rela.RelationName = tmp.RelationName;
}
rela.Scheme = new ProbScheme(-1, tmp.Scheme.SchemeName, tmp.Scheme.Attributes);
foreach (ProbTuple item in tmp.tuples)
{
ProbTuple tuple = new ProbTuple(item);
rela.tuples.Add(tuple);
}
probRelations.Add(rela);
}
if (probRelations.Count == 2)
{
if (probRelations[0].RelationName == probRelations[1].RelationName)
{
MessageError = String.Format("The correlation name '{0}' is specified multiple times in a FROM clause.", probRelations[0].RenameRelationName);
return(null);
}
}
foreach (ProbRelation item in probRelations)
{
if (item.RelationName != string.Empty)
{
try
{
int value = Convert.ToInt32(item.RelationName);
MessageError = String.Format("Incorrect syntax near '{0}'.", item.RelationName);
return(null);
}
catch (Exception)
{
}
}
}
return(probRelations);
}
private List <double> GetProbIntervalV3(string valueOne, string valueTwo, string operaterStr)
{
double minProb = 0, maxProb = 0;
int indexOne, countTripleOne;
ProbTuple tuple = this.tuple;
try
{
if (SelectCondition.isCompareOperator(operaterStr)) // Biểu thức so sánh giữa một thuộc tính với một giá trị
{
indexOne = this.IndexOfAttribute(valueOne); // vị trí của thuộc tính trong ds các thuộc tính
if (indexOne == -1)
{
return(null);
}
if (valueTwo.Contains("'"))
{
int count = valueTwo.Split(new char[] { '\'' }).Length - 1;
if (valueTwo.Substring(0, 1) != "'")
{
MessageError = "Unclosed quotation mark before the character string " + valueTwo;
return(null);
}
if (valueTwo.Substring(valueTwo.Length - 1, 1) != "'")
{
MessageError = "Unclosed quotation mark after the character string " + valueTwo;
return(null);
}
if (count != 2)
{
MessageError = "Unclosed quotation mark at the character string " + valueTwo;
return(null);
}
valueTwo = valueTwo.Remove(0, 1);
valueTwo = valueTwo.Remove(valueTwo.Length - 1, 1);
}
#region ProbDataType
ProbDataType dataType = new ProbDataType();
dataType.TypeName = Attributes[indexOne].Type.TypeName;
dataType.DataType = Attributes[indexOne].Type.DataType;
dataType.Domain = Attributes[indexOne].Type.Domain;
dataType.DomainString = Attributes[indexOne].Type.DomainString;
#endregion
if (!dataType.CheckDataTypeOfVariables(valueTwo))
{
MessageError = String.Format("Conversion failed when converting the varchar value {0} to data type {1}.", valueTwo, dataType.DataType);
return(null);
}
#region ProbDataType
countTripleOne = tuple.Triples[indexOne].Value.Count; // số lượng các cặp xác xuất trong thuộc tính
var listValue = tuple.Triples[indexOne].Value;
var minProbV = tuple.Triples[indexOne].MinProb;
var maxProbV = tuple.Triples[indexOne].MaxProb;
#endregion
var result = listValue.Where(x => CompareTriple(x, valueTwo, operaterStr, dataType.TypeName)).Count();
if (result > 0)
{
minProb = (result / (float)countTripleOne) * minProbV;
maxProb = (result / (float)countTripleOne) * maxProbV;
return(new List <double> {
minProb, maxProb
});
}
else
{
return(new List <double> {
0, 0
});
}
}
return(null);
}
catch
{
MessageError = "Incorrect syntax near 'where'.";
return(null);
}
}
private bool GetProbIntervalV2(string valueOne, string valueTwo, string operaterStr, double?maxProbOfCon = null, double?minProbOfCon = null)
{
double minProb = 0, maxProb = 0;
int indexOne, countTripleOne;
ProbTuple tuple = this.tuple;
try
{
if (SelectCondition.isCompareOperator(operaterStr)) // Biểu thức so sánh giữa một thuộc tính với một giá trị
{
indexOne = this.IndexOfAttribute(valueOne); // vị trí của thuộc tính trong ds các thuộc tính
if (indexOne == -1)
{
return(false);
}
if (valueTwo.Contains("'"))
{
int count = valueTwo.Split(new char[] { '\'' }).Length - 1;
if (valueTwo.Substring(0, 1) != "'")
{
MessageError = "Unclosed quotation mark before the character string " + valueTwo;
return(false);
}
if (valueTwo.Substring(valueTwo.Length - 1, 1) != "'")
{
MessageError = "Unclosed quotation mark after the character string " + valueTwo;
return(false);
}
if (count != 2)
{
MessageError = "Unclosed quotation mark at the character string " + valueTwo;
return(false);
}
valueTwo = valueTwo.Remove(0, 1);
valueTwo = valueTwo.Remove(valueTwo.Length - 1, 1);
}
#region ProbDataType
ProbDataType dataType = new ProbDataType();
dataType.TypeName = Attributes[indexOne].Type.TypeName;
dataType.DataType = Attributes[indexOne].Type.DataType;
dataType.Domain = Attributes[indexOne].Type.Domain;
dataType.DomainString = Attributes[indexOne].Type.DomainString;
#endregion
if (!dataType.CheckDataTypeOfVariables(valueTwo))
{
MessageError = String.Format("Conversion failed when converting the varchar value {0} to data type {1}.", valueTwo, dataType.DataType);
return(false);
}
#region ProbDataType
countTripleOne = tuple.Triples[indexOne].Value.Count; // số lượng các cặp xác xuất trong thuộc tính
var listValue = tuple.Triples[indexOne].Value;
var minProbV = tuple.Triples[indexOne].MinProb;
var maxProbV = tuple.Triples[indexOne].MaxProb;
#endregion
if (maxProbV == 1 && minProbV == 1 && !maxProbOfCon.HasValue && !minProbOfCon.HasValue)
{
var kp = listValue.Any(x => CompareTriple(x, valueTwo, operaterStr, dataType.TypeName));
return(kp);
}
else
{
var count = listValue.Where(x => CompareTriple(x, valueTwo, operaterStr, dataType.TypeName)).Count();
if (count > 0)
{
minProb = (count / (float)countTripleOne) * minProbV;
maxProb = (count / (float)countTripleOne) * maxProbV;
if (maxProbOfCon.HasValue && minProbOfCon.HasValue)
{
return(minProbOfCon.Value <= minProb && maxProb <= maxProbOfCon);
}
}
return(false);
}
}
else // Biểu thức kết hợp giữa hai khoảng xác suất
{
double minProbOne, minProbTwo, maxProbOne, maxProbTwo;
string[] StrProb;
valueOne = valueOne.Replace("[", ""); // [L,U]
valueOne = valueOne.Replace("]", "");
StrProb = valueOne.Split(',');
minProbOne = Convert.ToDouble(StrProb[0]);
maxProbOne = Convert.ToDouble(StrProb[1]);
valueTwo = valueTwo.Replace("[", ""); // [L,U]
valueTwo = valueTwo.Replace("]", "");
StrProb = valueTwo.Split(',');
minProbTwo = Convert.ToDouble(StrProb[0]);
maxProbTwo = Convert.ToDouble(StrProb[1]);
switch (operaterStr)
{
case "⊗_ig": minProb = Math.Max(0, minProbOne + minProbTwo - 1); maxProb = Math.Min(maxProbOne, maxProbTwo); break;
case "⊗_in": minProb = minProbOne * minProbTwo; maxProb = maxProbOne * maxProbTwo; break;
case "⊗_me": minProb = 0; maxProb = 0; break;
case "⊕_ig": minProb = Math.Max(minProbOne, minProbTwo); maxProb = Math.Min(1, maxProbOne + maxProbTwo); break;
case "⊕_in": minProb = minProbOne + minProbTwo - (minProbOne * minProbTwo); maxProb = maxProbOne + maxProbTwo - (maxProbOne * maxProbTwo); break;
case "⊕_me": minProb = Math.Min(1, minProbOne + minProbTwo); maxProb = Math.Min(1, maxProbOne + maxProbTwo); break;
default:
MessageError = "Incorrect syntax near 'where'.";
break;
}
}
}
catch
{
MessageError = "Incorrect syntax near 'where'.";
return(false);
}
return(false);
}
private string GetProbInterval(string valueOne, string valueTwo, string operaterStr)
{
double minProb = 0, maxProb = 0;
int indexOne, indexTwo, countTripleOne, countTripleTwo;
ProbTuple tuple = this.tuple;
string typenameOne;
string typenameTwo;
try
{
if (operaterStr.Contains("equal_ig") || operaterStr.Contains("equal_in") || operaterStr.Contains("equal_me")) // Biểu thức so sánh bằng giữa hai thuộc tính trên cùng một bộ
{
indexOne = IndexOf(valueOne);
indexTwo = IndexOf(valueTwo);
if (indexOne == -1 || indexTwo == -1)
{
return(string.Empty);
}
countTripleOne = tuple.Triples[indexOne].Value.Count;
countTripleTwo = tuple.Triples[indexTwo].Value.Count;
typenameOne = Attributes[indexOne].Type.DataType;
typenameTwo = Attributes[indexTwo].Type.DataType;
if (typenameOne != typenameTwo)
{
//Attribute value does not match the data type !
MessageError = String.Format("Error :{0} and {1} must the same data type", valueOne, valueTwo);
return(string.Empty);
}
for (int i = 0; i < countTripleOne; i++)
{
for (int j = 0; j < countTripleTwo; j++)
{
if (EQUAL(tuple.Triples[indexOne].Value[i].ToString().Trim(), tuple.Triples[indexTwo].Value[j].ToString().Trim(), typenameOne))
{
switch (operaterStr)
{
case "equal_in":
minProb += tuple.Triples[indexOne].MinProb[i] * tuple.Triples[indexTwo].MinProb[j];
maxProb = Math.Min(1, maxProb + tuple.Triples[indexOne].MaxProb[i] * tuple.Triples[indexTwo].MaxProb[j]);
break;
case "equal_ig":
minProb += Math.Min(0, tuple.Triples[indexOne].MinProb[i] + tuple.Triples[indexTwo].MinProb[j] - 1);
maxProb = Math.Min(1, maxProb + Math.Min(tuple.Triples[indexOne].MaxProb[i], tuple.Triples[indexTwo].MaxProb[j]));
break;
case "equal_me":
minProb = 0;
maxProb = Math.Min(1, maxProb + 0);
break;
default: break;
}
}
}
}
}
else
if (SelectCondition.isCompareOperator(operaterStr)) // Biểu thức so sánh giữa một thuộc tính với một giá trị
{
indexOne = this.IndexOf(valueOne); // vị trí của thuộc tính trong ds các thuộc tính
if (indexOne == -1)
{
return(string.Empty);
}
if (valueTwo.Contains("'"))
{
int count = valueTwo.Split(new char[] { '\'' }).Length - 1;
if (valueTwo.Substring(0, 1) != "'")
{
MessageError = "Unclosed quotation mark before the character string " + valueTwo;
return(string.Empty);
}
if (valueTwo.Substring(valueTwo.Length - 1, 1) != "'")
{
MessageError = "Unclosed quotation mark after the character string " + valueTwo;
return(string.Empty);
}
if (count != 2)
{
MessageError = "Unclosed quotation mark at the character string " + valueTwo;
return(string.Empty);
}
valueTwo = valueTwo.Remove(0, 1);
valueTwo = valueTwo.Remove(valueTwo.Length - 1, 1);
}
countTripleOne = tuple.Triples[indexOne].Value.Count; // số lượng các cặp xác xuất trong thuộc tính
typenameOne = Attributes[indexOne].Type.DataType;
ProbDataType dataType = new ProbDataType();
dataType.TypeName = Attributes[indexOne].Type.TypeName;
dataType.DataType = Attributes[indexOne].Type.DataType;
dataType.Domain = Attributes[indexOne].Type.Domain;
dataType.DomainString = Attributes[indexOne].Type.DomainString;
if (!dataType.CheckDataTypeOfVariables(valueTwo))
{
MessageError = String.Format("Conversion failed when converting the varchar value {0} to data type {1}.", valueTwo, typenameOne);
return(string.Empty);
}
for (int i = 0; i < countTripleOne; i++)
{
if (this.CompareTriple(tuple.Triples[indexOne].Value[i].ToString().Trim(), valueTwo.Trim(), operaterStr, typenameOne)) // duyệt từng cặp xác xuất và so sánh
{
minProb += tuple.Triples[indexOne].MinProb[i];
maxProb += tuple.Triples[indexOne].MaxProb[i];
}
}
}
else // Biểu thức kết hợp giữa hai khoảng xác suất
{
double minProbOne, minProbTwo, maxProbOne, maxProbTwo;
string[] StrProb;
valueOne = valueOne.Replace("[", ""); // [L,U]
valueOne = valueOne.Replace("]", "");
StrProb = valueOne.Split(',');
minProbOne = Convert.ToDouble(StrProb[0]);
maxProbOne = Convert.ToDouble(StrProb[1]);
valueTwo = valueTwo.Replace("[", ""); // [L,U]
valueTwo = valueTwo.Replace("]", "");
StrProb = valueTwo.Split(',');
minProbTwo = Convert.ToDouble(StrProb[0]);
maxProbTwo = Convert.ToDouble(StrProb[1]);
switch (operaterStr)
{
case "⊗_ig": minProb = Math.Max(0, minProbOne + minProbTwo - 1); maxProb = Math.Min(maxProbOne, maxProbTwo); break;
case "⊗_in": minProb = minProbOne * minProbTwo; maxProb = maxProbOne * maxProbTwo; break;
case "⊗_me": minProb = 0; maxProb = 0; break;
case "⊕_ig": minProb = Math.Max(minProbOne, minProbTwo); maxProb = Math.Min(1, maxProbOne + maxProbTwo); break;
case "⊕_in": minProb = minProbOne + minProbTwo - (minProbOne * minProbTwo); maxProb = maxProbOne + maxProbTwo - (maxProbOne * maxProbTwo); break;
case "⊕_me": minProb = Math.Min(1, minProbOne + minProbTwo); maxProb = Math.Min(1, maxProbOne + maxProbTwo); break;
default: MessageError = "Incorrect syntax near 'where'.";
break;
}
}
}
catch
{
MessageError = "Incorrect syntax near 'where'.";
return(string.Empty);
}
maxProb = 1 > maxProb ? maxProb : 1; // check maxProb
return(String.Format("[{0},{1}]", minProb, maxProb));
}
private List <ProbRelation> GetAllRelation(string valueString)
{
int posOne;
int posTwo;
string relationsString = string.Empty;
List <string> listOfRelationName = this.probDatabase.ListOfRelationNameToLower();
string[] seperator = { "," };
string[] relations;
List <ProbRelation> probRelations = new List <ProbRelation>();
//////////////////////// Get Relations ///////////////////////
posOne = valueString.IndexOf(Common.From) + 4;
if (!valueString.Contains(Common.Where))
{
posTwo = valueString.Length - 1;
}
else
{
posTwo = valueString.IndexOf(Common.Where) - 1;
}
relationsString = valueString.Substring(posOne, posTwo - posOne + 1); // Get Relation in the Query Text
if (relationsString.Trim().Length <= 0)
{
MessageError = "No relation exists in the query !";
return(null);
}
if (relationsString.Contains(","))
{
relations = relationsString.Split(seperator, StringSplitOptions.RemoveEmptyEntries);
}
else
{
if (relationsString.Contains(Common.NaturalJoinIn) || relationsString.Contains(Common.NaturalJoinIg) || relationsString.Contains(Common.NaturalJoinMe))
{
var listRaltion = relationsString.Split(new string[] { "natural join" }, StringSplitOptions.RemoveEmptyEntries);
relations = new string[listRaltion.Length];
for (int i = 0; i < listRaltion.Length; i++)
{
if (i == 0)
{
relations[i] = listRaltion[i];
}
else
{
string[] listTmp = listRaltion[i].Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (listTmp.Length != 2 && listTmp.Length != 3)
{
MessageError = String.Format("Incorrect syntax near '{0}'.", listRaltion[i]);
return(null);
}
if (!listTmp[0].Contains("in") && !listTmp[0].Contains("ig") && !listTmp[0].Contains("me"))
{
MessageError = String.Format("Incorrect syntax near '{0}'.", listRaltion[i]);
return(null);
}
OperationNaturalJoin.Add(listTmp[0]);
if (listTmp.Length == 2)
{
relations[i] = listTmp[1];
}
else
{
relations[i] = listTmp[1] + " " + listTmp[2];
}
}
}
flagNaturalJoin = true;
}
else
{
relations = new string[1];
relations[0] = relationsString;
}
}
for (int i = 0; i < relations.Length; i++)
{
string[] listTmp = relations[i].Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (!listOfRelationName.Contains(listTmp[0].ToLower()))
{
MessageError = String.Format("Invalid relation name '{0}'.", listTmp[0]);
return(null);
}
if (listTmp.Length > 2)
{
MessageError = String.Format("Invalid relation name '{0}'.", relations[i]);
return(null);
}
ProbRelation tmp = this.probDatabase.Relations.SingleOrDefault(c => c.RelationName.ToLower().Equals(listTmp[0], StringComparison.OrdinalIgnoreCase));
ProbRelation rela = new ProbRelation();
if (listTmp.Length == 2)
{
rela.RelationName = listTmp[1];
}
else
{
rela.RelationName = tmp.RelationName;
}
rela.Scheme = new ProbScheme(-1, tmp.Scheme.SchemeName, tmp.Scheme.Attributes);
foreach (ProbTuple item in tmp.tuples)
{
ProbTuple tuple = new ProbTuple(item);
rela.tuples.Add(tuple);
}
probRelations.Add(rela);
}
return(probRelations);
}
