245 lines
7.5 KiB
Java
245 lines
7.5 KiB
Java
package Ext_Tools;
|
|
|
|
/**
|
|
*
|
|
* <b> Task of this class </b> <br/>
|
|
* It represents a predicate which basically consists of ValueExpressions and Operators.
|
|
* It can also contain a subquery.
|
|
* It also represents BoolPrim, BoolTest and BoolFactor since they do not differ much from predicate
|
|
*/
|
|
public class WhereElement {
|
|
|
|
private boolean NotExpr = false; // it is for a bool-factor: not Bool-Test
|
|
private StringBuffer RVC1;
|
|
private StringBuffer RVC1Quali = new StringBuffer("");
|
|
private StringBuffer RVC2;
|
|
private StringBuffer RVC2Quali = new StringBuffer("");
|
|
private String FirstOperator;
|
|
private String SecondOperator;
|
|
private boolean QualifierNeeded;
|
|
private boolean SubqueryInUse;
|
|
private QueryClause Sub;
|
|
private QualifierList QList;
|
|
private WhereClause SearchCond;
|
|
private boolean SearchCondinUse;
|
|
|
|
|
|
/**
|
|
*
|
|
* <b> Task of this constructor </b> <br/>
|
|
* it creates a WhereElement without a subquery. It checks whether qualifiers are needed and
|
|
* in case they are needed it stores the needed qualifiers in a QualifierList
|
|
* @param rvc1
|
|
* @param rvc2
|
|
* @param op
|
|
*/
|
|
public WhereElement(String rvc1, String rvc2, String op) {
|
|
this.QList = new QualifierList();
|
|
this.RVC1 = new StringBuffer(rvc1);
|
|
this.QualifierNeeded = this.check4Qualifiers(this.RVC1, this.RVC1Quali);
|
|
if (this.QualifierNeeded)
|
|
this.QList.addQualifier(new Qualifier(this.RVC1.toString(), this.RVC1Quali.toString()));
|
|
this.RVC2 = new StringBuffer(rvc2);
|
|
if (this.check4Qualifiers(this.RVC2, this.RVC2Quali)) {
|
|
this.QList.addQualifier(new Qualifier(this.RVC2.toString(), this.RVC2Quali.toString()));
|
|
this.QualifierNeeded = true;
|
|
}
|
|
this.FirstOperator = op;
|
|
this.SecondOperator = "";
|
|
this.SubqueryInUse = false;
|
|
this.SearchCondinUse = false;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* <b> Task of this constructor </b> <br/>
|
|
* creates a WhereElement with a subquery. It also checks whether a qualifier is needed and
|
|
* stores the needed qualifier in a QualifierList
|
|
*@param rvc
|
|
*@param op1
|
|
*@param op2
|
|
*@param sub
|
|
*/
|
|
public WhereElement(String rvc, String op1, String op2, QueryClause sub) {
|
|
this.QList = new QualifierList();
|
|
this.RVC1 = new StringBuffer(rvc);
|
|
this.QualifierNeeded = this.check4Qualifiers(this.RVC1, this.RVC1Quali);
|
|
if (this.QualifierNeeded)
|
|
this.QList.addQualifier(new Qualifier(this.RVC1.toString(), this.RVC1Quali.toString()));
|
|
this.RVC2 = new StringBuffer("");
|
|
this.FirstOperator = op1.trim();
|
|
this.SecondOperator = op2.trim();
|
|
this.SubqueryInUse = true;
|
|
this.Sub = sub;
|
|
this.SearchCondinUse = false;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* <b> Task of this constructor </b> <br/>
|
|
* It is needed in case a Bool-Primary does not just contain a predicate but a
|
|
* Search Condition in brackets
|
|
* @param wc
|
|
*/
|
|
public WhereElement(WhereClause wc) {
|
|
this.SearchCond = wc;
|
|
this.SubqueryInUse = false;
|
|
this.SearchCondinUse = true;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* <b> Task of this method </b> <br/>
|
|
* if this WhereElement contains a subquery the upper query for the subquery is set here
|
|
* @param UQ
|
|
*/
|
|
public void SetUpperQuery(QueryClause UQ) {
|
|
if (this.SubqueryInUse)
|
|
this.Sub.SetUpperClause(UQ);
|
|
}
|
|
|
|
public boolean isSubqueryInUse() {
|
|
return this.SubqueryInUse;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* <b> Task of this method </b> <br/>
|
|
* A BoolFactor can contain NOT
|
|
*/
|
|
public void SetNotExpr() {
|
|
this.NotExpr = true;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* <b> Task of this method </b> <br/>
|
|
* outputs the WhereElement as a string
|
|
* it throws an exception in case the QueryExpression has a groupby-conflict
|
|
* @return
|
|
*/
|
|
public String getWhereElement() throws Exception{
|
|
String result;
|
|
|
|
if (!this.SubqueryInUse && !this.SearchCondinUse) {
|
|
result = this.addQualiToElement(RVC1Quali.toString(), RVC1.toString());
|
|
result += this.FirstOperator;
|
|
result += this.addQualiToElement(RVC2Quali.toString(), RVC2.toString());
|
|
}
|
|
else if (this.SearchCondinUse) {
|
|
result = "(" + this.SearchCond.getWhereClause() + ")";
|
|
}
|
|
else {
|
|
if (this.FirstOperator.equalsIgnoreCase("exists"))
|
|
result = "[exists" + this.Sub.getQueryExpression() + "]";
|
|
else {
|
|
result = this.addQualiToElement(RVC1Quali.toString(), RVC1.toString());
|
|
if (this.FirstOperator != "")
|
|
result += " " + this.FirstOperator + " "; // in case first operator is Not_Expression it could be ""
|
|
if (this.SecondOperator != "") {
|
|
if (this.checkForQuantifier(this.SecondOperator))
|
|
result += "(" + this.SecondOperator + this.Sub.getQueryExpression() +")"; //... where no > (any (subclause))
|
|
else
|
|
result += " " + this.SecondOperator + this.Sub.getQueryExpression(); // ... where no not in (subclause)
|
|
}
|
|
else
|
|
result += this.Sub.getQueryExpression(); // ... where no > (subclause)
|
|
//result += " " + this.Sub.getQueryExpression();
|
|
}
|
|
}
|
|
|
|
if (this.NotExpr)
|
|
result = "not " + result;
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* <b> Task of this method </b> <br/>
|
|
* connects qualifier and attribut to one expression. Needed for output as a string
|
|
* @param quali
|
|
* @param elem
|
|
* @return
|
|
*/
|
|
private String addQualiToElement(String quali, String elem) {
|
|
String result;
|
|
|
|
result = elem;
|
|
if (!quali.equalsIgnoreCase(""))
|
|
result = quali + ":" + result;
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* <b> Task of this method </b> <br/>
|
|
* checks whether a passed operator is a quantifier such as all, any ...
|
|
* @param quanti
|
|
* @return
|
|
*/
|
|
private boolean checkForQuantifier(String quanti) {
|
|
boolean result = false;
|
|
if (quanti.equalsIgnoreCase("all") || quanti.equalsIgnoreCase("any") || quanti.equalsIgnoreCase("some"))
|
|
result = true;
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* <b> Task of this method </b> <br/>
|
|
* checks whether the passed attribut contains a qualifier and stores the attribut under Att and
|
|
* the qualifier under Quali. Att and Quali need to be StringBuffer because they are changed and
|
|
* need to be passed back.
|
|
* @param Att
|
|
* @param Quali
|
|
* @return
|
|
*/
|
|
private boolean check4Qualifiers(StringBuffer Att, StringBuffer Quali) {
|
|
boolean result = false;
|
|
int PosColon;
|
|
|
|
PosColon = Att.indexOf(":");
|
|
if (PosColon!=-1) {
|
|
Quali.append(Att.substring(0, PosColon));
|
|
Att = Att.delete(0, PosColon+1);
|
|
result = true;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* <b> Task of this method </b> <br/>
|
|
* the passed QualifierList will be added with the qualifiers needed in the subquery or
|
|
* with the qualifiers of this WhereElement
|
|
* @param ql
|
|
* @return true if ql contains Qualifiers
|
|
*/
|
|
public boolean getQualifierNeeded(QualifierList ql) {
|
|
|
|
if (!this.SearchCondinUse) {
|
|
if (this.SubqueryInUse)
|
|
this.Sub.SetQualifier(ql); // ql is filled if the Subquery needs a qualifier
|
|
|
|
/* this.QList is the QualifierList created by this WhereElement. ql is the
|
|
* QualifierList with can contain many other Qualifiers from different WhereElements,
|
|
* this Subquery or can be empty. It is important to call addQualifierList from ql
|
|
* because the passed QualifierList needs to be filled up with Qualifiers. If we
|
|
* would fill up this.QList and then assign ql=this.QList only the formal parameter
|
|
* will be assigned to a new QList. The actual parameter will still point to the same
|
|
* QList as before.
|
|
*/
|
|
if (this.QualifierNeeded)
|
|
this.QList = ql.addQualifierList(this.QList);
|
|
}
|
|
else
|
|
this.SearchCond.NeedQualifier(ql);
|
|
|
|
return (!ql.isEmpty());
|
|
}
|
|
|
|
}
|