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 SelectCondition(ProbRelation probRelation, string conditionString)
{
// TODO: Complete member initialization
relations = probRelation;
int i = 0;
while (i < conditionString.Length - 1)
{
if (conditionString[i] == '<' && conditionString[i + 1] != '=')
{
conditionString = conditionString.Insert(i++, "_");
}
if (conditionString[i] == '>' && conditionString[i + 1] != '=')
{
conditionString = conditionString.Insert(i++, "_");
}
if (conditionString[i] == '=' && conditionString[i - 1] != '!' && conditionString[i - 1] != '<' && conditionString[i - 1] != '>')
{
conditionString = conditionString.Insert(i++, "_");
}
i++;
}
this.conditionString = conditionString.Trim();
this.Attributes = probRelation.Scheme.Attributes;
this.MessageError = string.Empty;
}
private ProbRelation NaturalJoin(ProbRelation relationResult, ProbRelation relationInput, string operationRa)
{
ProbRelation relation = Descartes(relationResult, relationInput);
List <int> indexsRemove = new List <int>();
var totalAttributesOne = relation.Scheme.Attributes.Count - relationInput.Scheme.Attributes.Count;
for (int i = 0; i < totalAttributesOne; i++)
{
for (int j = totalAttributesOne; j < relation.Scheme.Attributes.Count; j++)
{
if (i != j && relation.Scheme.Attributes[i].Type.DataType == relation.Scheme.Attributes[j].Type.DataType)
{
string attributeOne = relation.Scheme.Attributes[i].AttributeName.Substring(relation.Scheme.Attributes[i].AttributeName.IndexOf(".") + 1);
string attributeTwo = relation.Scheme.Attributes[j].AttributeName.Substring(relation.Scheme.Attributes[j].AttributeName.IndexOf(".") + 1);
if (attributeOne.Equals(attributeTwo, StringComparison.CurrentCultureIgnoreCase))
{
indexsRemove.Add(j);
for (int k = relation.tuples.Count - 1; k >= 0; k--)
{
ProbTriple triple = JoinTwoTriple(relation.tuples[k].Triples[i], relation.tuples[k].Triples[j], relation.Scheme.Attributes[i], operationRa);
if (triple != null)
{
relation.tuples[k].Triples[i] = triple;
relation.tuples[k].Triples[j] = triple;
}
else
{
relation.tuples.RemoveAt(k);
}
}
}
}
}
}
var check = relation.Scheme.Attributes.Count() == this.selectedAttributes.Count();
if (check)
{
for (int i = 0; i < indexsRemove.Count; i++)
{
foreach (ProbTuple tuple in relation.tuples)
{
tuple.Triples.RemoveAt(indexsRemove[i]);
}
relation.Scheme.Attributes.RemoveAt(indexsRemove[i]);
this.selectedAttributes.RemoveAt(indexsRemove[i]);
}
}
//OperationNaturalJoin = string.Empty;
flagNaturalJoin = false;
return(relation);
}
private ProbRelation Descartes(ProbRelation relationOne, ProbRelation relationTwo)
{
ProbRelation relation = new ProbRelation();
GenerateNewRelation(relation, relationOne);
GenerateNewRelation(relation, relationTwo);
JoinTwoRelation(relation, relationOne, relationTwo);
return(relation);
}
private ProbRelation NaturalJoin()
{
ProbRelation relation = Descartes();
List <int> indexsRemove = new List <int>();
for (int i = 0; i < relation.Scheme.Attributes.Count - this.selectedRelations[1].Scheme.Attributes.Count; i++)
{
for (int j = this.selectedRelations[1].Scheme.Attributes.Count; j < relation.Scheme.Attributes.Count; j++)
{
if (i != j && relation.Scheme.Attributes[i].Type.DataType == relation.Scheme.Attributes[j].Type.DataType) //cung kieu du lien
{
string attributeOne = relation.Scheme.Attributes[i].AttributeName.Substring(relation.Scheme.Attributes[i].AttributeName.IndexOf(".") + 1);
string attributeTwo = relation.Scheme.Attributes[j].AttributeName.Substring(relation.Scheme.Attributes[j].AttributeName.IndexOf(".") + 1);
if (attributeOne.Equals(attributeTwo, StringComparison.CurrentCultureIgnoreCase)) //cung ten attr (!= bang)
{
indexsRemove.Add(j); //j danh dau truong chung de bo ra
for (int k = relation.tuples.Count - 1; k >= 0; k--)
{
ProbTriple triple = JoinTwoTriple(relation.tuples[k].Triples[i], relation.tuples[k].Triples[j], relation.Scheme.Attributes[i], this.OperationNaturalJoin);
if (triple != null)
{
relation.tuples[k].Triples[i] = triple;
relation.tuples[k].Triples[j] = triple;
}
else
{
//value is not equal
relation.tuples.RemoveAt(k);
}
}
}
}
}
}
for (int i = 0; i < indexsRemove.Count; i++)
{
foreach (ProbTuple tuple in relation.tuples)
{
tuple.Triples.RemoveAt(indexsRemove[i]);
}
relation.Scheme.Attributes.RemoveAt(indexsRemove[i]);
this.selectedAttributes.RemoveAt(indexsRemove[i]);
}
OperationNaturalJoin = string.Empty;
flagNaturalJoin = false;
return(relation);
}
private void GenerateNewRelation(ProbRelation relation, ProbRelation relationInput)
{
relation.ListRenameRelation.Add(relationInput.RelationName);
foreach (ProbAttribute attr in relationInput.Scheme.Attributes)
{
if (attr.AttributeName.IndexOf(".") == -1)
{
attr.AttributeName = relationInput.RelationName + "." + attr.AttributeName;
}
}
relation.Scheme.Attributes.AddRange(relationInput.Scheme.Attributes);
}
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);
}
}
}
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 <ProbAttribute> GetAttribute(string valueString)
{
List <ProbAttribute> listProbAttribute = new List <ProbAttribute>();
//////////////////////// Get Attributes //////////////////////
int posOne, posTwo;
// * là chọn tất cả các thuộc tính
if (valueString.Contains("*"))
{
posOne = valueString.IndexOf("*"); // start postion of attributes
posTwo = valueString.IndexOf("from ") - 1;
if (posOne > posTwo)
{
MessageError = "Incorrect syntax near 'from'.";
return(null);
}
if (posOne < valueString.IndexOf("select"))
{
MessageError = "Incorrect syntax near 'select'.";
return(null);
}
if (valueString.Contains("where") && posOne > valueString.IndexOf("where"))
{
MessageError = "Incorrect syntax near 'where'.";
return(null);
}
if (posOne != valueString.LastIndexOf("*"))
{
MessageError = "Incorrect syntax near 'select'.";
return(null);
}
// end postion of attributes
string attributes = valueString.Substring(posOne, posTwo - posOne + 1);
// Nếu như phia sau dấu * có bất kì kí tự nào thì sẽ thông báo lỗi
if (attributes.Trim().Length > 1)
{
MessageError = "Incorrect syntax near 'select'.";
return(null);
}
// thực hiện sao chép toàn bộ thuộc tính của các quan hệ vào danh sách thuộc tính chọn
for (int i = 0; i < this.selectedRelations.Count; i++)
{
foreach (ProbAttribute attr in this.selectedRelations[i].Scheme.Attributes)
{
attr.AttributeName = String.Format("{0}.{1}", this.selectedRelations[i].RelationName, attr.AttributeName);
listProbAttribute.Add(attr);
}
}
return(listProbAttribute);
}
else // ngược lại là xuất theo thuộc tính chỉ định
{
posOne = valueString.IndexOf("select") + 6; // start postion of attributes
posTwo = valueString.IndexOf("from ") - 1; // end postion of attributes
string attributes = valueString.Substring(posOne, posTwo - posOne + 1);
//kiểm tra cú pháp của chuổi thuộc tính
if (!QueryExecution.CheckStringAttribute(attributes))
{
MessageError = "Incorrect syntax near 'select'.";
return(null);
}
else
{
string[] seperator = { "," };
string[] attribute = attributes.Split(seperator, StringSplitOptions.RemoveEmptyEntries); // split thành mảng các thuộc tính
foreach (string str in attribute)
{
if (!str.Contains("."))
{
string attributeName = str.Trim();
int countOne = 0;
int countSameAttribute = 0;
foreach (ProbRelation relation in this.selectedRelations)
{
List <string> listOfAttributeName = relation.Scheme.ListOfAttributeNameToLower();
if (listOfAttributeName.Contains(attributeName.ToLower()))
{
ProbAttribute attr = new ProbAttribute(relation.Scheme.Attributes[listOfAttributeName.IndexOf(attributeName)]);
attr.AttributeName = String.Format("{0}.{1}", relation.RelationName, attr.AttributeName);
listProbAttribute.Add(attr);
countSameAttribute++;
}
else
{
countOne++;
}
}
if (countOne == this.selectedRelations.Count)
{
MessageError = String.Format(" Invalid attribute name '{0}'.", attributeName);
return(null);
}
if (countSameAttribute == this.selectedRelations.Count && this.selectedRelations.Count >= 2)
{
MessageError = String.Format(" Ambiguous attribute name '{0}'.", attributeName);
return(null);
}
}
else
{
string[] array = str.Split(new char[] { '.' }, StringSplitOptions.RemoveEmptyEntries);
if (array.Length != 2)
{
MessageError = "Incorrect syntax near the keyword 'select'.";
return(null);
}
ProbRelation relation = this.selectedRelations.SingleOrDefault(c => c.RelationName.Trim() == array[0].Trim());
if (relation == null)
{
MessageError = String.Format("The multi-part identifier '{0}' could not be bound.", str);
return(null);
}
ProbAttribute attr = new ProbAttribute(relation.Scheme.Attributes.SingleOrDefault(c => c.AttributeName.Trim().ToLower() == array[1].Trim()));
attr.AttributeName = String.Format("{0}.{1}", relation.RelationName, attr.AttributeName);
if (attr == null)
{
MessageError = "Invalid attribute name '" + array[1] + "'.";
return(null);
}
listProbAttribute.Add(attr);
}
}
return(listProbAttribute);
}
}
}
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);
}
