This is an automated email from the ASF dual-hosted git repository.
doebele pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/empire-db.git
The following commit(s) were added to refs/heads/master by this push:
new 4d05a79 EMPIREDB-362 implemened equals() for all DBColumnExpr and
added FunctionExpression UnitTest
4d05a79 is described below
commit 4d05a799fa3ca3b729813ecb74dfbbbb26755783
Author: Rainer Döbele <[email protected]>
AuthorDate: Wed Feb 23 13:50:12 2022 +0100
EMPIREDB-362 implemened equals() for all DBColumnExpr and added
FunctionExpression UnitTest
---
.../org/apache/empire/data/list/DataListHead.java | 4 +-
.../java/org/apache/empire/db/DBRecordData.java | 4 +-
.../empire/db/expr/column/DBAbstractFuncExpr.java | 32 ++--
.../apache/empire/db/expr/column/DBAliasExpr.java | 39 +++--
.../apache/empire/db/expr/column/DBCalcExpr.java | 25 +++
.../apache/empire/db/expr/column/DBCaseExpr.java | 29 +++-
.../empire/db/expr/column/DBCoalesceExpr.java | 23 +--
.../apache/empire/db/expr/column/DBConcatExpr.java | 25 +--
.../empire/db/expr/column/DBConcatFuncExpr.java | 25 +++
.../empire/db/expr/column/DBConvertExpr.java | 2 +-
.../apache/empire/db/expr/column/DBCountExpr.java | 22 +++
.../apache/empire/db/expr/column/DBScalarExpr.java | 21 +++
.../apache/empire/db/expr/column/DBValueExpr.java | 69 ++++----
.../empire/db/expr/column/DBVarArgsFuncExpr.java | 32 +++-
.../empire/db/expr/compare/DBCompareAndOrExpr.java | 15 +-
.../empire/db/expr/compare/DBCompareColExpr.java | 46 ++---
.../empire/db/expr/compare/DBCompareNotExpr.java | 15 +-
.../empire/db/expr/compare/DBExistsExpr.java | 2 +-
.../org/apache/empire/db/AliasExpressionTest.java | 13 +-
.../apache/empire/db/CoalesceExpressionTest.java | 14 +-
.../apache/empire/db/FunctionExpressionTest.java | 189 +++++++++++++++++++++
21 files changed, 502 insertions(+), 144 deletions(-)
diff --git
a/empire-db/src/main/java/org/apache/empire/data/list/DataListHead.java
b/empire-db/src/main/java/org/apache/empire/data/list/DataListHead.java
index 2e31f23..d486b83 100644
--- a/empire-db/src/main/java/org/apache/empire/data/list/DataListHead.java
+++ b/empire-db/src/main/java/org/apache/empire/data/list/DataListHead.java
@@ -126,7 +126,7 @@ public class DataListHead implements Serializable
}
else
{ // convert to String
- text = convertToString(column, value);
+ text = formatValue(column, value);
}
// Done
return text;
@@ -138,7 +138,7 @@ public class DataListHead implements Serializable
* @param value the value to format
* @return the formatted string
*/
- protected String convertToString(ColumnExpr column, Object value)
+ protected String formatValue(ColumnExpr column, Object value)
{
return ObjectUtils.getString(value);
}
diff --git a/empire-db/src/main/java/org/apache/empire/db/DBRecordData.java
b/empire-db/src/main/java/org/apache/empire/db/DBRecordData.java
index 1c80e9e..415b518 100644
--- a/empire-db/src/main/java/org/apache/empire/db/DBRecordData.java
+++ b/empire-db/src/main/java/org/apache/empire/db/DBRecordData.java
@@ -489,7 +489,7 @@ public abstract class DBRecordData extends DBObject
}
else
{ // convert to String
- text = convertToString(column, value);
+ text = formatValue(column, value);
}
// done
return text;
@@ -501,7 +501,7 @@ public abstract class DBRecordData extends DBObject
* @param value the value to format
* @return the formatted string
*/
- protected String convertToString(ColumnExpr column, Object value)
+ protected String formatValue(ColumnExpr column, Object value)
{
return ObjectUtils.getString(value);
}
diff --git
a/empire-db/src/main/java/org/apache/empire/db/expr/column/DBAbstractFuncExpr.java
b/empire-db/src/main/java/org/apache/empire/db/expr/column/DBAbstractFuncExpr.java
index b2fa6b9..54704cc 100644
---
a/empire-db/src/main/java/org/apache/empire/db/expr/column/DBAbstractFuncExpr.java
+++
b/empire-db/src/main/java/org/apache/empire/db/expr/column/DBAbstractFuncExpr.java
@@ -166,22 +166,28 @@ public abstract class DBAbstractFuncExpr extends
DBColumnExpr
{
expr.addReferencedColumns(list);
}
-
+
/**
- * check if other function is the same and applies to the same column
- * @param other
- * @return true if both functions are the same and on the same column or
false otherwise
+ * Returns true if other is equal to this expression
*/
- public boolean isMutuallyExclusive(DBAbstractFuncExpr other)
+ @Override
+ public boolean equals(Object other)
{
- String tname = getFunctionName();
- String oname = other.getFunctionName();
- if (StringUtils.compareNotEqual(tname, oname))
- return false;
- // check update columns
- DBColumn tcol = getUpdateColumn();
- DBColumn ocol = other.getUpdateColumn();
- return (tcol!=null) ? (tcol.equals(ocol)) : false;
+ if (other==this)
+ return true;
+ // Check Type
+ if (other instanceof DBAbstractFuncExpr)
+ { // Compare
+ DBAbstractFuncExpr otherFunc = (DBAbstractFuncExpr)other;
+ // Expression must match
+ if (!expr.equals(otherFunc.expr))
+ return false;
+ // Function must match
+ String tname = getFunctionName();
+ String oname = otherFunc.getFunctionName();
+ return StringUtils.compareEqual(tname, oname);
+ }
+ return false;
}
/**
diff --git
a/empire-db/src/main/java/org/apache/empire/db/expr/column/DBAliasExpr.java
b/empire-db/src/main/java/org/apache/empire/db/expr/column/DBAliasExpr.java
index 7698c57..2f7e77f 100644
--- a/empire-db/src/main/java/org/apache/empire/db/expr/column/DBAliasExpr.java
+++ b/empire-db/src/main/java/org/apache/empire/db/expr/column/DBAliasExpr.java
@@ -154,6 +154,25 @@ public class DBAliasExpr extends DBColumnExpr
{
return expr.isAggregate();
}
+
+ /**
+ * Overrides the equals method
+ * @return true if alias name and expression match
+ */
+ @Override
+ public boolean equals(Object other)
+ {
+ if (other==this)
+ return true;
+ // Check for another Alias Expression
+ if (other instanceof DBAliasExpr)
+ { // Compare with another alias expression
+ DBAliasExpr otherExpr = ((DBAliasExpr)other);
+ return this.alias.equalsIgnoreCase(otherExpr.getName()) &&
+ this.expr.equals(otherExpr.unwrap());
+ }
+ return false;
+ }
/**
* @see org.apache.empire.db.DBExpr#addReferencedColumns(Set)
@@ -208,26 +227,6 @@ public class DBAliasExpr extends DBColumnExpr
}
return field;
}
-
- /**
- * Overrides the equals method
- *
- * @return true if alias name and expression match
- */
- @Override
- public boolean equals(Object other)
- {
- if (other==this)
- return true;
- // Check for another Alias Expression
- if (other instanceof DBAliasExpr)
- { // Compare with another alias expression
- DBAliasExpr otherExpr = ((DBAliasExpr)other);
- return this.alias.equalsIgnoreCase(otherExpr.getName()) &&
- this.expr.equals(otherExpr.unwrap());
- }
- return false;
- }
/**
* Overrides the toString method.
diff --git
a/empire-db/src/main/java/org/apache/empire/db/expr/column/DBCalcExpr.java
b/empire-db/src/main/java/org/apache/empire/db/expr/column/DBCalcExpr.java
index 47be0aa..73a84e4 100644
--- a/empire-db/src/main/java/org/apache/empire/db/expr/column/DBCalcExpr.java
+++ b/empire-db/src/main/java/org/apache/empire/db/expr/column/DBCalcExpr.java
@@ -22,6 +22,7 @@ package org.apache.empire.db.expr.column;
import java.util.Date;
import java.util.Set;
+import org.apache.empire.commons.ObjectUtils;
import org.apache.empire.commons.StringUtils;
import org.apache.empire.data.DataType;
import org.apache.empire.db.DBColumn;
@@ -164,6 +165,30 @@ public class DBCalcExpr extends DBColumnExpr
{
return false;
}
+
+ /**
+ * Returns true if other is equal to this expression
+ */
+ @Override
+ public boolean equals(Object other)
+ {
+ if (other==this)
+ return true;
+ // Check Type
+ if (other instanceof DBCalcExpr)
+ { // Compare
+ DBCalcExpr otherCalc = (DBCalcExpr)other;
+ // Expression must match
+ if (!expr.equals(otherCalc.expr))
+ return false;
+ // Operators must match
+ if (!StringUtils.compareEqual(this.op, otherCalc.op))
+ return false;
+ // Compare values
+ return ObjectUtils.compareEqual(this.value, otherCalc.value);
+ }
+ return false;
+ }
/**
* @see org.apache.empire.db.DBExpr#addReferencedColumns(Set)
diff --git
a/empire-db/src/main/java/org/apache/empire/db/expr/column/DBCaseExpr.java
b/empire-db/src/main/java/org/apache/empire/db/expr/column/DBCaseExpr.java
index 7efde69..e6746c4 100644
--- a/empire-db/src/main/java/org/apache/empire/db/expr/column/DBCaseExpr.java
+++ b/empire-db/src/main/java/org/apache/empire/db/expr/column/DBCaseExpr.java
@@ -18,6 +18,8 @@
*/
package org.apache.empire.db.expr.column;
+import java.util.Set;
+
import org.apache.empire.data.DataType;
import org.apache.empire.db.DBColumn;
import org.apache.empire.db.DBColumnExpr;
@@ -26,8 +28,6 @@ import org.apache.empire.db.expr.compare.DBCompareExpr;
import org.apache.empire.xml.XMLUtil;
import org.w3c.dom.Element;
-import java.util.Set;
-
/**
* This class is used to add the "case when ?=A then X else Y end" statement
to the SQL-Command.
* <P>
@@ -99,6 +99,31 @@ public class DBCaseExpr extends DBColumnExpr
{
return trueExpr.isAggregate();
}
+
+ /**
+ * Returns true if other is equal to this expression
+ */
+ @Override
+ public boolean equals(Object other)
+ {
+ if (other==this)
+ return true;
+ // Check Type
+ if (other instanceof DBCaseExpr)
+ { // Compare
+ DBCaseExpr otherCase = (DBCaseExpr)other;
+ // Expression must match
+ if (!compExpr.equals(otherCase.compExpr))
+ return false;
+ if (!trueExpr.equals(otherCase.trueExpr))
+ return false;
+ // finally compare elseExpr
+ if (elseExpr==null)
+ return (otherCase.elseExpr==null);
+ return elseExpr.equals(otherCase.elseExpr);
+ }
+ return false;
+ }
@Override
public void addReferencedColumns(Set<DBColumn> list)
diff --git
a/empire-db/src/main/java/org/apache/empire/db/expr/column/DBCoalesceExpr.java
b/empire-db/src/main/java/org/apache/empire/db/expr/column/DBCoalesceExpr.java
index 2f86ad6..ec5891e 100644
---
a/empire-db/src/main/java/org/apache/empire/db/expr/column/DBCoalesceExpr.java
+++
b/empire-db/src/main/java/org/apache/empire/db/expr/column/DBCoalesceExpr.java
@@ -23,12 +23,12 @@ public class DBCoalesceExpr extends DBAbstractFuncExpr
}
/**
- * Should we return true here?
+ * This is a transparent wrapper
*/
@Override
public boolean isWrapper()
- {
- return false; // Should we return true here?
+ { // yep
+ return true;
}
@Override
@@ -62,16 +62,16 @@ public class DBCoalesceExpr extends DBAbstractFuncExpr
}
/**
- * Compares true if the other is also a coalesce expr on the same column
+ * Returns true if other is equal to this expression
*/
@Override
public boolean equals(Object other)
{
if (other==this)
return true;
- // Check for another Alias Expression
+ // Check Type
if (other instanceof DBCoalesceExpr)
- { // Compare with another alias expression
+ { // Compare expressions
DBColumnExpr otherExpr = ((DBCoalesceExpr)other).expr;
return this.expr.equals(otherExpr);
}
@@ -79,17 +79,6 @@ public class DBCoalesceExpr extends DBAbstractFuncExpr
}
/**
- * check if other function is the same and applies to the same column
- * @param other
- * @return true if both functions are the same and on the same column or
false otherwise
- */
- @Override
- public boolean isMutuallyExclusive(DBAbstractFuncExpr other)
- {
- return equals(other);
- }
-
- /**
* @see org.apache.empire.db.DBExpr#addReferencedColumns(Set)
*/
@Override
diff --git
a/empire-db/src/main/java/org/apache/empire/db/expr/column/DBConcatExpr.java
b/empire-db/src/main/java/org/apache/empire/db/expr/column/DBConcatExpr.java
index d89ff0f..cc7d616 100644
--- a/empire-db/src/main/java/org/apache/empire/db/expr/column/DBConcatExpr.java
+++ b/empire-db/src/main/java/org/apache/empire/db/expr/column/DBConcatExpr.java
@@ -134,6 +134,20 @@ public class DBConcatExpr extends DBColumnExpr
{
return false;
}
+
+ /**
+ * Returns true if other is equal to this expression
+ */
+ @Override
+ public boolean equals(Object other)
+ {
+ if (other instanceof DBConcatExpr)
+ { // Compare left and right
+ return left .equals(((DBConcatExpr)other).left)
+ && right.equals(((DBConcatExpr)other).right);
+ }
+ return false;
+ }
/**
* @see org.apache.empire.db.DBExpr#addReferencedColumns(Set)
@@ -177,15 +191,4 @@ public class DBConcatExpr extends DBColumnExpr
}
}
-
- @Override
- public boolean equals(Object other)
- {
- if (other instanceof DBConcatExpr)
- { // Compare left and right
- return left .equals(((DBConcatExpr)other).left)
- && right.equals(((DBConcatExpr)other).right);
- }
- return false;
- }
}
diff --git
a/empire-db/src/main/java/org/apache/empire/db/expr/column/DBConcatFuncExpr.java
b/empire-db/src/main/java/org/apache/empire/db/expr/column/DBConcatFuncExpr.java
index 03cc024..1ded662 100644
---
a/empire-db/src/main/java/org/apache/empire/db/expr/column/DBConcatFuncExpr.java
+++
b/empire-db/src/main/java/org/apache/empire/db/expr/column/DBConcatFuncExpr.java
@@ -74,6 +74,31 @@ public class DBConcatFuncExpr extends DBAbstractFuncExpr
{
return "CONCAT";
}
+
+ /**
+ * Returns true if other is equal to this expression
+ */
+ @Override
+ public boolean equals(Object other)
+ {
+ if (other==this)
+ return true;
+ // Check Type
+ if (other instanceof DBConcatFuncExpr)
+ { // Compare
+ DBConcatFuncExpr otherFunc = (DBConcatFuncExpr)other;
+ // Expression must match
+ if (!first.equals(otherFunc.first))
+ return false;
+ // all parts must match
+ for (int i=0; i<others.length; i++)
+ if (!others[i].equals(otherFunc.others[i]))
+ return false;
+ // OK
+ return true;
+ }
+ return false;
+ }
@Override
public void addSQL(StringBuilder buf, long context)
diff --git
a/empire-db/src/main/java/org/apache/empire/db/expr/column/DBConvertExpr.java
b/empire-db/src/main/java/org/apache/empire/db/expr/column/DBConvertExpr.java
index 1749fac..34c4678 100644
---
a/empire-db/src/main/java/org/apache/empire/db/expr/column/DBConvertExpr.java
+++
b/empire-db/src/main/java/org/apache/empire/db/expr/column/DBConvertExpr.java
@@ -52,7 +52,7 @@ public class DBConvertExpr extends DBAbstractFuncExpr
@Override
protected String getFunctionName()
{
- return "convert";
+ return dataType.name();
}
@Override
diff --git
a/empire-db/src/main/java/org/apache/empire/db/expr/column/DBCountExpr.java
b/empire-db/src/main/java/org/apache/empire/db/expr/column/DBCountExpr.java
index 96134e5..270fa81 100644
--- a/empire-db/src/main/java/org/apache/empire/db/expr/column/DBCountExpr.java
+++ b/empire-db/src/main/java/org/apache/empire/db/expr/column/DBCountExpr.java
@@ -157,6 +157,28 @@ public class DBCountExpr extends DBColumnExpr
{
return true;
}
+
+ /**
+ * Returns true if other is equal to this expression
+ */
+ @Override
+ public boolean equals(Object other)
+ {
+ if (other==this)
+ return true;
+ // Check Type
+ if (other instanceof DBCountExpr)
+ { // Compare
+ DBCountExpr otherCount = (DBCountExpr)other;
+ // Expression must match
+ if (this.column!=null)
+ return column.equals(otherCount.column);
+ if (this.rowset!=null)
+ return rowset.equals(otherCount.rowset);
+ // Should not come here
+ }
+ return false;
+ }
/**
* @see org.apache.empire.db.DBExpr#addReferencedColumns(Set)
diff --git
a/empire-db/src/main/java/org/apache/empire/db/expr/column/DBScalarExpr.java
b/empire-db/src/main/java/org/apache/empire/db/expr/column/DBScalarExpr.java
index 779228b..32c6c01 100644
--- a/empire-db/src/main/java/org/apache/empire/db/expr/column/DBScalarExpr.java
+++ b/empire-db/src/main/java/org/apache/empire/db/expr/column/DBScalarExpr.java
@@ -182,6 +182,27 @@ public class DBScalarExpr extends DBColumnExpr
{
return false;
}
+
+ /**
+ * Returns true if other is equal to this expression
+ */
+ @Override
+ public boolean equals(Object other)
+ {
+ if (other==this)
+ return true;
+ // Check Type
+ if (other instanceof DBScalarExpr)
+ { // Compare with same type
+ DBScalarExpr otherFunc = (DBScalarExpr)other;
+ // DataTypes must match
+ if (!dataType.equals(otherFunc.dataType))
+ return false;
+ // Templates must match
+ return StringUtils.compareEqual(this.template, otherFunc.template);
+ }
+ return false;
+ }
/**
* @see org.apache.empire.db.DBExpr#addReferencedColumns(Set)
diff --git
a/empire-db/src/main/java/org/apache/empire/db/expr/column/DBValueExpr.java
b/empire-db/src/main/java/org/apache/empire/db/expr/column/DBValueExpr.java
index fd30683..d9150b8 100644
--- a/empire-db/src/main/java/org/apache/empire/db/expr/column/DBValueExpr.java
+++ b/empire-db/src/main/java/org/apache/empire/db/expr/column/DBValueExpr.java
@@ -46,8 +46,6 @@ public class DBValueExpr extends DBColumnExpr
public final DBDatabase db;
public final DataType type;
- public final DBColumnExpr column;
- // the underlying value
protected Object value;
/**
@@ -61,20 +59,6 @@ public class DBValueExpr extends DBColumnExpr
{
this.db = db;
this.type = type;
- this.column = null;
- this.value = value;
- }
-
- /**
- * Construct a new DBValueExpr object set the specified parameters to this
object.
- * @param col the column
- * @param value the value
- */
- public DBValueExpr(DBColumnExpr col, Object value)
- {
- this.column = col;
- this.type = col.getDataType();
- this.db = col.getDatabase();
this.value = value;
}
@@ -141,31 +125,24 @@ public class DBValueExpr extends DBColumnExpr
@Override
public String getName()
{
- return (column != null) ? column.getName() : null;
+ return "VAL_"+String.valueOf(value);
}
/** this helper function calls the DBColumnExpr.addXML(Element, long)
method */
@Override
public Element addXml(Element parent, long flags)
{
- Element elem;
- if (column!=null)
- { // Update Column
- elem = column.addXml(parent, flags);
- }
- else
- { // Add a column expression for this function
- elem = XMLUtil.addElement(parent, "column");
- String name = getName();
- if (name!=null)
- elem.setAttribute("name", getName());
- // Add Other Attributes
- if (attributes!=null)
- attributes.addXml(elem, flags);
- // add All Options
- if (options!=null)
- options.addXml(elem, this.type);
- }
+ // Add a column expression for this function
+ Element elem = XMLUtil.addElement(parent, "column");
+ String name = getName();
+ if (name!=null)
+ elem.setAttribute("name", getName());
+ // Add Other Attributes
+ if (attributes!=null)
+ attributes.addXml(elem, flags);
+ // add All Options
+ if (options!=null)
+ options.addXml(elem, this.type);
// Done
elem.setAttribute("function", "value");
return elem;
@@ -177,7 +154,7 @@ public class DBValueExpr extends DBColumnExpr
@Override
public DBColumn getSourceColumn()
{
- return (column != null) ? column.getSourceColumn() : null;
+ return null;
}
/**
@@ -186,7 +163,7 @@ public class DBValueExpr extends DBColumnExpr
@Override
public DBColumn getUpdateColumn()
{
- return (column != null) ? column.getUpdateColumn() : null;
+ return null;
}
/**
@@ -199,6 +176,24 @@ public class DBValueExpr extends DBColumnExpr
{
return false;
}
+
+ /**
+ * Returns true if other is equal to this expression
+ */
+ @Override
+ public boolean equals(Object other)
+ {
+ if (other==this)
+ return true;
+ // Check Type
+ if (other instanceof DBValueExpr)
+ { // Compare
+ Object otherValue = ((DBValueExpr)other).value;
+ // Values must match
+ return ObjectUtils.compareEqual(value, otherValue);
+ }
+ return false;
+ }
/**
* Creates the SQL-Command.
diff --git
a/empire-db/src/main/java/org/apache/empire/db/expr/column/DBVarArgsFuncExpr.java
b/empire-db/src/main/java/org/apache/empire/db/expr/column/DBVarArgsFuncExpr.java
index 77a3639..4c57c17 100644
---
a/empire-db/src/main/java/org/apache/empire/db/expr/column/DBVarArgsFuncExpr.java
+++
b/empire-db/src/main/java/org/apache/empire/db/expr/column/DBVarArgsFuncExpr.java
@@ -20,6 +20,7 @@ package org.apache.empire.db.expr.column;
import java.util.Set;
+import org.apache.empire.commons.StringUtils;
import org.apache.empire.data.DataType;
import org.apache.empire.db.DBColumn;
import org.apache.empire.db.DBColumnExpr;
@@ -77,6 +78,34 @@ public class DBVarArgsFuncExpr extends DBColumnExpr
{
return false;
}
+
+ /**
+ * Returns true if other is equal to this expression
+ */
+ @Override
+ public boolean equals(Object other)
+ {
+ if (other==this)
+ return true;
+ // Check Type
+ if (other instanceof DBVarArgsFuncExpr)
+ { // Compare with same type
+ DBVarArgsFuncExpr otherFunc = (DBVarArgsFuncExpr)other;
+ // DataTypes must match
+ if (!dataType.equals(otherFunc.dataType))
+ return false;
+ // Templates must match
+ if (!StringUtils.compareEqual(this.template, otherFunc.template))
+ return false;
+ // all parts must match
+ for (int i=0; i<cols.length; i++)
+ if (!cols[i].equals(otherFunc.cols[i]))
+ return false;
+ // OK
+ return true;
+ }
+ return false;
+ }
@Override
public DBColumn getSourceColumn()
@@ -118,8 +147,7 @@ public class DBVarArgsFuncExpr extends DBColumnExpr
String postfix = "";
int sep = template.indexOf("?");
if (sep >= 0)
- {
- prefix = template.substring(0, sep);
+ { prefix = template.substring(0, sep);
postfix = template.substring(sep + 1);
}
// append
diff --git
a/empire-db/src/main/java/org/apache/empire/db/expr/compare/DBCompareAndOrExpr.java
b/empire-db/src/main/java/org/apache/empire/db/expr/compare/DBCompareAndOrExpr.java
index 06084af..3455a2b 100644
---
a/empire-db/src/main/java/org/apache/empire/db/expr/compare/DBCompareAndOrExpr.java
+++
b/empire-db/src/main/java/org/apache/empire/db/expr/compare/DBCompareAndOrExpr.java
@@ -20,6 +20,7 @@ package org.apache.empire.db.expr.compare;
import java.util.Set;
+import org.apache.empire.commons.Unwrappable;
import org.apache.empire.db.DBColumn;
import org.apache.empire.db.DBCommand;
import org.apache.empire.db.DBDatabase;
@@ -160,18 +161,24 @@ public class DBCompareAndOrExpr extends DBCompareExpr
}
/**
- * Returns wheter the constraint should replace another one or not.
+ * Returns whether the constraint should replace another one or not.
*
* @return true it the constraints are mutually exclusive or false
otherwise
*/
+ @SuppressWarnings("unchecked")
@Override
public boolean isMutuallyExclusive(DBCompareExpr other)
{
+ if (other instanceof Unwrappable<?>)
+ {
+ other = ((Unwrappable<DBCompareExpr>)other).unwrap();
+ }
if (other instanceof DBCompareAndOrExpr)
{
- DBCompareAndOrExpr o = (DBCompareAndOrExpr)other;
- if (left.equals(o.left) && right.equals(o.right))
- return true;
+ DBCompareAndOrExpr otherExpr = (DBCompareAndOrExpr)other;
+ if (left .isMutuallyExclusive(otherExpr.left) &&
+ right.isMutuallyExclusive(otherExpr.right))
+ return (this.or==otherExpr.or);
}
return false;
}
diff --git
a/empire-db/src/main/java/org/apache/empire/db/expr/compare/DBCompareColExpr.java
b/empire-db/src/main/java/org/apache/empire/db/expr/compare/DBCompareColExpr.java
index e4c24df..8f5816e 100644
---
a/empire-db/src/main/java/org/apache/empire/db/expr/compare/DBCompareColExpr.java
+++
b/empire-db/src/main/java/org/apache/empire/db/expr/compare/DBCompareColExpr.java
@@ -28,8 +28,6 @@ import org.apache.empire.db.DBColumnExpr;
import org.apache.empire.db.DBCommand;
import org.apache.empire.db.DBDatabase;
import org.apache.empire.db.DBExpr;
-import org.apache.empire.db.expr.column.DBAbstractFuncExpr;
-import org.apache.empire.db.expr.column.DBAliasExpr;
/**
@@ -295,38 +293,30 @@ public class DBCompareColExpr extends DBCompareExpr
@Override
public boolean isMutuallyExclusive(DBCompareExpr other)
{
+ // check type
if (other instanceof DBCompareColExpr)
- {
- DBCompareColExpr o = (DBCompareColExpr)other;
- DBColumnExpr oexpr = o.getColumn();
- if (expr.equals(oexpr))
- return true;
- // unwrap
+ { // unwrap
DBColumnExpr texpr = expr;
- if (texpr instanceof DBAliasExpr)
- texpr = ((DBAliasExpr) texpr).unwrap();
- if (oexpr instanceof DBAliasExpr)
- oexpr = ((DBAliasExpr) oexpr).unwrap();
- // check function expression
- boolean tfunc = (texpr instanceof DBAbstractFuncExpr);
- boolean ofunc = (oexpr instanceof DBAbstractFuncExpr);
- if (tfunc || ofunc)
- { // check if both are the same
- if (tfunc && ofunc)
- { // both are functions
- return
((DBAbstractFuncExpr)texpr).isMutuallyExclusive((DBAbstractFuncExpr)oexpr);
- }
- else
- { // not the same
- return false;
- }
- }
- // finally check update columns
+ if (texpr.isWrapper())
+ texpr = texpr.unwrap();
+ // other
+ DBCompareColExpr o = (DBCompareColExpr)other;
+ DBColumnExpr oexpr = o.getColumn();
+ if (oexpr.isWrapper())
+ oexpr = oexpr.unwrap();
+ // Compare
+ if (texpr.equals(oexpr))
+ return true;
+ /*
+ // probably not a good idea to do this:
DBColumn tcol = texpr.getSourceColumn();
DBColumn ocol = oexpr.getSourceColumn();
return (tcol!=null) ? (tcol.equals(ocol)) : false;
+ */
+ return false;
}
- return false;
+ // other types
+ return equals(other);
}
}
\ No newline at end of file
diff --git
a/empire-db/src/main/java/org/apache/empire/db/expr/compare/DBCompareNotExpr.java
b/empire-db/src/main/java/org/apache/empire/db/expr/compare/DBCompareNotExpr.java
index c506152..f386872 100644
---
a/empire-db/src/main/java/org/apache/empire/db/expr/compare/DBCompareNotExpr.java
+++
b/empire-db/src/main/java/org/apache/empire/db/expr/compare/DBCompareNotExpr.java
@@ -20,6 +20,7 @@ package org.apache.empire.db.expr.compare;
import java.util.Set;
+import org.apache.empire.commons.Unwrappable;
import org.apache.empire.db.DBColumn;
import org.apache.empire.db.DBCommand;
import org.apache.empire.db.DBDatabase;
@@ -113,14 +114,24 @@ public class DBCompareNotExpr extends DBCompareExpr
}
/**
- * Returns wheter the constraint should replace another one or not.
+ * Returns whether the constraint should replace another one or not.
*
* @return true it the constraints are mutually exclusive or false
otherwise
*/
+ @SuppressWarnings("unchecked")
@Override
public boolean isMutuallyExclusive(DBCompareExpr other)
{
- return false;
+ if (other instanceof Unwrappable<?>)
+ {
+ other = ((Unwrappable<DBCompareExpr>)other).unwrap();
+ }
+ if (other instanceof DBCompareNotExpr)
+ {
+ DBCompareNotExpr otherNot = (DBCompareNotExpr)other;
+ return expr.isMutuallyExclusive(otherNot.expr);
+ }
+ return false;
}
}
\ No newline at end of file
diff --git
a/empire-db/src/main/java/org/apache/empire/db/expr/compare/DBExistsExpr.java
b/empire-db/src/main/java/org/apache/empire/db/expr/compare/DBExistsExpr.java
index d9f56b9..9b9953d 100644
---
a/empire-db/src/main/java/org/apache/empire/db/expr/compare/DBExistsExpr.java
+++
b/empire-db/src/main/java/org/apache/empire/db/expr/compare/DBExistsExpr.java
@@ -159,7 +159,7 @@ public class DBExistsExpr extends DBCompareExpr
if (other instanceof DBExistsExpr)
{
DBExistsExpr o = (DBExistsExpr)other;
- if (cmd==o.cmd && compareExpr==o.compareExpr)
+ if (cmd.equals(o.cmd) && compareExpr.equals(o.compareExpr))
return true;
}
return false;
diff --git
a/empire-db/src/test/java/org/apache/empire/db/AliasExpressionTest.java
b/empire-db/src/test/java/org/apache/empire/db/AliasExpressionTest.java
index 74ea828..7085c9e 100644
--- a/empire-db/src/test/java/org/apache/empire/db/AliasExpressionTest.java
+++ b/empire-db/src/test/java/org/apache/empire/db/AliasExpressionTest.java
@@ -19,10 +19,13 @@
package org.apache.empire.db;
+import java.util.List;
+
import org.apache.empire.data.DataType;
import org.apache.empire.data.list.DataListEntry;
import org.apache.empire.data.list.DataListHead;
import org.apache.empire.db.context.DBContextStatic;
+import org.apache.empire.db.expr.compare.DBCompareExpr;
import org.junit.Test;
import junit.framework.Assert;
@@ -34,7 +37,7 @@ import junit.framework.Assert;
public class AliasExpressionTest
{
/**
- * Test Standard DBRecord with Serializable Context
+ * Test Alias Expression
*/
@Test
public void testAliasExpression()
@@ -67,6 +70,14 @@ public class AliasExpressionTest
DBColumnExpr[] expr = cmd.getSelectExprList();
// Hint: ALIAS_2_NEU is not a separate column
Assert.assertEquals(expr.length, 4);
+ // where
+ cmd.where(ALIAS_1.isNot("Foo1"));
+ cmd.where(ALIAS_2.isNot("Foo2"));
+ cmd.where(ALIAS_2_NEU.isNot("Foo3"));
+ cmd.where(ALIAS_X.isNot("Foo4"));
+ // System.out.println(cmd.getSelect());
+ List<DBCompareExpr> list = cmd.getWhereConstraints();
+ Assert.assertEquals(list.size(), 1);
// Query Record
DBQuery q = new DBQuery(cmd);
diff --git
a/empire-db/src/test/java/org/apache/empire/db/CoalesceExpressionTest.java
b/empire-db/src/test/java/org/apache/empire/db/CoalesceExpressionTest.java
index 7fc9be8..d5e2210 100644
--- a/empire-db/src/test/java/org/apache/empire/db/CoalesceExpressionTest.java
+++ b/empire-db/src/test/java/org/apache/empire/db/CoalesceExpressionTest.java
@@ -19,10 +19,13 @@
package org.apache.empire.db;
+import java.util.List;
+
import org.apache.empire.data.DataType;
import org.apache.empire.data.list.DataListEntry;
import org.apache.empire.data.list.DataListHead;
import org.apache.empire.db.context.DBContextStatic;
+import org.apache.empire.db.expr.compare.DBCompareExpr;
import org.junit.Test;
import junit.framework.Assert;
@@ -34,7 +37,7 @@ import junit.framework.Assert;
public class CoalesceExpressionTest
{
/**
- * Test Standard DBRecord with Serializable Context
+ * Test Coalesce Expression
*/
@Test
public void testCoalesceExpression()
@@ -68,6 +71,15 @@ public class CoalesceExpressionTest
DBColumnExpr[] expr = cmd.getSelectExprList();
// Hint: COALESCE_2_NEU is not a separate column
Assert.assertEquals(expr.length, 3);
+ // where
+ cmd.where(COALESCE_1.is("Foo1"));
+ cmd.where(COALESCE_2.is("Foo2"));
+ cmd.where(t.C_TEXT.is("Foo"));
+ cmd.where(AMOUNT.is(5));
+ cmd.where(t.C_NUMBER.coalesce(7).is(3));
+ // System.out.println(cmd.getSelect());
+ List<DBCompareExpr> list = cmd.getWhereConstraints();
+ Assert.assertEquals(list.size(), 2);
// Query Record
DBQuery q = new DBQuery(cmd);
diff --git
a/empire-db/src/test/java/org/apache/empire/db/FunctionExpressionTest.java
b/empire-db/src/test/java/org/apache/empire/db/FunctionExpressionTest.java
new file mode 100644
index 0000000..179be84
--- /dev/null
+++ b/empire-db/src/test/java/org/apache/empire/db/FunctionExpressionTest.java
@@ -0,0 +1,189 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.empire.db;
+
+import java.util.List;
+
+import org.apache.empire.data.DataType;
+import org.apache.empire.data.list.DataListEntry;
+import org.apache.empire.data.list.DataListHead;
+import org.apache.empire.db.context.DBContextStatic;
+import org.apache.empire.db.expr.compare.DBCompareExpr;
+import org.junit.Test;
+
+import junit.framework.Assert;
+
+/**
+ * @author rainer
+ * @since 23.01.22
+ */
+public class FunctionExpressionTest
+{
+ /**
+ * Test Column Function Expressions
+ */
+ @Test
+ public void testFunctionExpression()
+ throws Exception
+ {
+ final TestDatabase db = new TestDatabase();
+
+ DBContext context = new DBContextStatic(new MockDriver(), null);
+ db.open(context);
+
+ TestDatabase.TestTable t = db.T_TEST;
+ TestDatabase.TestTable t2 = t.clone("tclone");
+
+ DBColumn NUMBER = t.C_NUMBER;
+ DBColumnExpr TEST_COUNT = t.count();
+ DBColumnExpr TEST_2_COUNT = t2.count();
+ DBColumnExpr NUM_COUNT_1 = NUMBER.countDistinct();
+ DBColumnExpr NUM_COUNT_2 = NUMBER.countDistinct();
+ DBColumnExpr NUM_COUNT_3 = t2.C_NUMBER.countDistinct();
+ DBColumnExpr NUM_AVG_1 = NUMBER.avg();
+ DBColumnExpr NUM_AVG_2 = NUMBER.avg();
+ DBColumnExpr NUM_AVG_3 = t2.C_NUMBER.avg();
+ DBColumnExpr NUM_SUM_1 = NUMBER.sum();
+ DBColumnExpr NUM_SUM_2 = NUMBER.sum();
+ DBColumnExpr NUM_SUM_3 = t2.C_NUMBER.sum();
+
+ String test_count = TEST_COUNT.getName();
+ String name_count = NUM_COUNT_1.getName();
+ String name_avg = NUM_AVG_1.getName();
+ String name_sum = NUM_SUM_1.getName();
+ Assert.assertEquals(test_count, "TESTTABLE_COUNT");
+ Assert.assertEquals(name_count, "NUMBER_COUNT");
+ Assert.assertEquals(name_avg, "NUMBER_AVG");
+ Assert.assertEquals(name_sum, "NUMBER_SUM");
+
+ DBCommand cmd = context.createCommand();
+ cmd.select(NUMBER, TEST_COUNT, TEST_2_COUNT);
+ cmd.select(NUM_COUNT_1, NUM_COUNT_2, NUM_COUNT_3);
+ cmd.select(NUM_AVG_1, NUM_AVG_2, NUM_AVG_3);
+ cmd.select(NUM_SUM_1, NUM_SUM_2, NUM_SUM_3);
+ // System.out.println(cmd.getSelect());
+ DBColumnExpr[] expr = cmd.getSelectExprList();
+ Assert.assertEquals(expr.length, 9);
+ // where
+ cmd.where(NUM_AVG_1.isNot(0).or(NUM_SUM_1.isNot(0)).parenthesis());
+ cmd.where(NUM_AVG_1.isNot(1).or(NUM_SUM_1.isNot(1)));
+ cmd.where(NUM_COUNT_1.isMoreOrEqual(5));
+ cmd.where(NUM_COUNT_2.isMoreOrEqual(3));
+ cmd.where(NUM_COUNT_3.isMoreOrEqual(4));
+ cmd.where(NUM_AVG_1.isNot(0));
+ cmd.where(NUM_SUM_1.isLessOrEqual(25));
+ cmd.where(NUM_SUM_2.isNotBetween(0, 5));
+ cmd.where(NUM_SUM_3.isSmallerThan(55));
+ // System.out.println(cmd.getSelect());
+ List<DBCompareExpr> list = cmd.getWhereConstraints();
+ Assert.assertEquals(list.size(), 6);
+
+ // Query Record
+ DBQuery q = new DBQuery(cmd);
+ DBRecord record = new DBRecord(context, q);
+ Assert.assertEquals(record.getFieldIndex(NUMBER), 0);
+ Assert.assertEquals(record.getFieldIndex(TEST_COUNT), 1);
+ Assert.assertEquals(record.getFieldIndex(TEST_2_COUNT), 2);
+ Assert.assertEquals(record.getFieldIndex(NUM_COUNT_1), 3);
+ Assert.assertEquals(record.getFieldIndex(NUM_COUNT_2), 3);
+ Assert.assertEquals(record.getFieldIndex(NUM_COUNT_3), 4);
+ Assert.assertEquals(record.getFieldIndex(NUM_AVG_1), 5);
+ Assert.assertEquals(record.getFieldIndex(NUM_AVG_2), 5);
+ Assert.assertEquals(record.getFieldIndex(NUM_AVG_3), 6);
+ Assert.assertEquals(record.getFieldIndex(NUM_SUM_1), 7);
+ Assert.assertEquals(record.getFieldIndex(NUM_SUM_2), 7);
+ Assert.assertEquals(record.getFieldIndex(NUM_SUM_3), 8);
+
+ // Reader
+ DBReader reader = new MyReader(context);
+ reader.open(cmd);
+ Assert.assertEquals(reader.getFieldIndex(NUMBER), 0);
+ Assert.assertEquals(reader.getFieldIndex(TEST_COUNT), 1);
+ Assert.assertEquals(reader.getFieldIndex(TEST_2_COUNT), 2);
+ Assert.assertEquals(reader.getFieldIndex(NUM_COUNT_1), 3);
+ Assert.assertEquals(reader.getFieldIndex(NUM_COUNT_2), 3);
+ Assert.assertEquals(reader.getFieldIndex(NUM_COUNT_3), 4);
+ Assert.assertEquals(reader.getFieldIndex(NUM_AVG_1), 5);
+ Assert.assertEquals(reader.getFieldIndex(NUM_AVG_2), 5);
+ Assert.assertEquals(reader.getFieldIndex(NUM_AVG_3), 6);
+ Assert.assertEquals(reader.getFieldIndex(NUM_SUM_1), 7);
+ Assert.assertEquals(reader.getFieldIndex(NUM_SUM_2), 7);
+ Assert.assertEquals(reader.getFieldIndex(NUM_SUM_3), 8);
+ reader.close();
+
+ // DataListEntry
+ DataListHead head = new DataListHead(cmd.getSelectExprList());
+ Object[] values = new Object[head.getColumns().length];
+ for (int i=0; i<values.length; i++)
+ values[i] = head.getColumns()[i].getName();
+ DataListEntry dle = new DataListEntry(head, 0, values);
+ Assert.assertEquals(dle.getFieldIndex(NUMBER), 0);
+ Assert.assertEquals(dle.getFieldIndex(TEST_COUNT), 1);
+ Assert.assertEquals(dle.getFieldIndex(TEST_2_COUNT), 2);
+ Assert.assertEquals(dle.getFieldIndex(NUM_COUNT_1), 3);
+ Assert.assertEquals(dle.getFieldIndex(NUM_COUNT_2), 3);
+ Assert.assertEquals(dle.getFieldIndex(NUM_COUNT_3), 4);
+ Assert.assertEquals(dle.getFieldIndex(NUM_AVG_1), 5);
+ Assert.assertEquals(dle.getFieldIndex(NUM_AVG_2), 5);
+ Assert.assertEquals(dle.getFieldIndex(NUM_AVG_3), 6);
+ Assert.assertEquals(dle.getFieldIndex(NUM_SUM_1), 7);
+ Assert.assertEquals(dle.getFieldIndex(NUM_SUM_2), 7);
+ Assert.assertEquals(dle.getFieldIndex(NUM_SUM_3), 8);
+
+ // done
+ }
+
+ static class MyReader extends DBReader
+ {
+ public MyReader(DBContext context)
+ {
+ super(context, false);
+ }
+
+ @Override
+ public void open(DBCommandExpr cmd, boolean scrollable)
+ {
+ super.init(cmd.getDatabase(), cmd.getSelectExprList(), null);
+ }
+ }
+
+ /**
+ * Databae
+ */
+ static class TestDatabase extends DBDatabase
+ {
+ public final TestTable T_TEST = new TestTable(this);
+ static class TestTable extends DBTable
+ {
+ public final DBTableColumn C_ID;
+ public final DBTableColumn C_TEXT;
+ public final DBTableColumn C_NUMBER;
+
+ TestTable(DBDatabase db)
+ {
+ super("TESTTABLE", db);
+ this.C_ID = addColumn("id", DataType.INTEGER, 0, true);
+ this.C_TEXT = addColumn("TEXT", DataType.VARCHAR, 255, false);
+ this.C_NUMBER = addColumn("NUMBER", DataType.DECIMAL, 10.2,
false);
+ setPrimaryKey(C_ID);
+ }
+ }
+ }
+}
