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); }