You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@empire-db.apache.org by do...@apache.org on 2025/10/03 23:46:56 UTC
(empire-db) branch master updated: EMPIREDB-477 refactored and optimized
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 beb47d04 EMPIREDB-477 refactored and optimized
beb47d04 is described below
commit beb47d04b98694e9d64c7ca307bed87927a6ce0f
Author: Rainer Döbele <rd...@users.noreply.github.com>
AuthorDate: Sat Oct 4 01:46:52 2025 +0200
EMPIREDB-477
refactored and optimized
---
.../org/apache/empire/commons/ColumnUtils.java | 145 +++----------------
.../main/java/org/apache/empire/db/DBColumn.java | 160 ++++++++++++++++++++-
.../main/java/org/apache/empire/db/DBDatabase.java | 27 +++-
3 files changed, 200 insertions(+), 132 deletions(-)
diff --git a/empire-db/src/main/java/org/apache/empire/commons/ColumnUtils.java b/empire-db/src/main/java/org/apache/empire/commons/ColumnUtils.java
index 375a772b..a384d282 100644
--- a/empire-db/src/main/java/org/apache/empire/commons/ColumnUtils.java
+++ b/empire-db/src/main/java/org/apache/empire/commons/ColumnUtils.java
@@ -21,18 +21,13 @@ package org.apache.empire.commons;
import java.math.BigDecimal;
import java.text.NumberFormat;
import java.util.Locale;
-import java.util.regex.Pattern;
import org.apache.empire.data.Column;
import org.apache.empire.data.ColumnExpr;
import org.apache.empire.data.DataType;
import org.apache.empire.db.DBColumn;
import org.apache.empire.db.DBColumnExpr;
-import org.apache.empire.db.expr.column.DBFuncExpr;
-import org.apache.empire.exceptions.InvalidArgumentException;
import org.apache.empire.exceptions.NotSupportedException;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
/**
* ColumnUtils
@@ -41,7 +36,7 @@ import org.slf4j.LoggerFactory;
*/
public class ColumnUtils
{
- private static final Logger log = LoggerFactory.getLogger(ColumnUtils.class);
+ // private static final Logger log = LoggerFactory.getLogger(ColumnUtils.class);
/**
* The instance of ValueUtils to be used for value type conversion
@@ -138,30 +133,19 @@ public class ColumnUtils
*/
public static boolean isCaseSensitive(ColumnExpr columnExpr)
{
+ if (columnExpr instanceof DBColumn)
+ { // ask the column
+ return ((DBColumn)columnExpr).isCaseSensitive();
+ }
// only for text expressions
if (!isText(columnExpr))
return false;
// check attribute
Object value = instance.getColumnAttribute(columnExpr, Column.COLATTR_CASESENSITIVE);
- if (value==null)
- { // default is true for VARCHAR and CLOB except if Options or EnumType are set
- return (columnExpr.getOptions()==null && columnExpr.getEnumType()==null);
- }
- return ObjectUtils.getBoolean(value);
- }
-
- /**
- * Sets the case sensitivity of the columnExpr
- * @param columnExpr the columnExpr
- * @param caseSensitiv may be true, false or null
- * @return return the columnExpr
- */
- public static <T extends ColumnExpr> T setCaseSensitive(T columnExpr, Boolean caseSensitiv)
- {
- if (!isText(columnExpr))
- throw new NotSupportedException(columnExpr, "setCaseInsensitive");
- // set now
- return columnExpr.setAttribute(Column.COLATTR_CASESENSITIVE, caseSensitiv);
+ if (value!=null)
+ return ObjectUtils.getBoolean(value);
+ // default is true for VARCHAR and CLOB except if Options or EnumType are set
+ return (columnExpr.getOptions()==null && columnExpr.getEnumType()==null);
}
/**
@@ -181,60 +165,26 @@ public class ColumnUtils
}
/**
- * Returns the sort expression for a given column
- * If no sort expression is explicitly set then the column itself is returned
- * The returned expression should be assigned to an DBCommand.orderBy() function.
- *
- * @param column the column for which to retrieve the sort expression
- * @return the sort expression or the column itself if not sort expression is set
+ * Returns the normalized column for the columnExpr (if any)
+ * The column expression must be a column otherwise null is returned
+ * @return the normalized column or null
*/
- public static DBColumnExpr getSortExpr(DBColumn column)
+ public static DBColumnExpr getNormalizedColumn(DBColumnExpr columnExpr)
{
- Object value = instance.getColumnAttribute(column, Column.COLATTR_SORTEXPRESSION);
- // create a sort expression
- if (value instanceof DBColumnExpr)
- { // return expression
- return ((DBColumnExpr)value);
- }
- else if ((value instanceof String) && ((String)value).indexOf('?')>=0)
- { // create a sort function expression
- String sortFunctionTemplate = StringUtils.toString(value);
- return new DBFuncExpr(column, sortFunctionTemplate, null, false, column.getDataType());
- }
- else if (value!=null)
- { // unknown value
- log.warn("Invalid value for {}: {}", Column.COLATTR_SORTEXPRESSION, value);
- }
- // not changed
- return column;
- }
-
- /**
- * Sets a sort function expression for a given column
- * @param column the column for which to set the sort expression
- * @param sortExpression the expression which to use for sorting
- * @return return the column
- */
- public static <T extends DBColumn> T setSortExpr(T column, DBColumnExpr sortExpression)
- { // set sort expression
- column.setAttribute(Column.COLATTR_SORTEXPRESSION, sortExpression);
- return column;
+ return ((columnExpr instanceof DBColumn) ? ((DBColumn)columnExpr).getNormalizedColumn() : null);
}
-
+
/**
- * Sets a sort function template for a given column
- * @param column the column for which to set the sort expression
- * @param sortFunctionTemplate the template which must contain a ? which will be replaced with the column name
- * @return return the column
+ * Returns the sort expression for a given column expression
+ * This function checks if columnExpr is a column and callse column.getSortExpr().
+ * If columnExpr is not a colunn, the columnExpr itself is returned
+ *
+ * @param columnExpr the columnExpr for which to retrieve the sort expression
+ * @return the sort expression or the column itself if not sort expression is set
*/
- public static <T extends DBColumn> T setSortExpr(T column, String sortFunctionTemplate)
+ public static DBColumnExpr getSortExpr(DBColumnExpr columnExpr)
{
- // check param
- if (sortFunctionTemplate!=null && sortFunctionTemplate.indexOf('?')<0)
- throw new InvalidArgumentException("sortFunctionTemplate", sortFunctionTemplate);
- // set sort expression
- column.setAttribute(Column.COLATTR_SORTEXPRESSION, sortFunctionTemplate);
- return column;
+ return ((columnExpr instanceof DBColumn) ? ((DBColumn)columnExpr).getSortExpr() : columnExpr);
}
/**
@@ -332,55 +282,6 @@ public class ColumnUtils
return column;
}
- /**
- * Returns the maximum allowed value
- * @param columnExpr the columnExpr
- * @return the minimum length
- */
- public static Pattern getRegExPattern(ColumnExpr columnExpr)
- {
- Object value = instance.getColumnAttribute(columnExpr, Column.COLATTR_REGEXP);
- return ((Pattern)value);
- }
-
- /**
- * Set the regular expression to validate the columnExpr value
- * @param columnExpr the columnExpr
- * @param regex the regular expression
- * @return the columnExpr
- */
- public static <T extends ColumnExpr> T setRegExPattern(T columnExpr, String regex)
- {
- columnExpr.setAttribute(Column.COLATTR_REGEXP, Pattern.compile(regex));
- return columnExpr;
- }
-
- /**
- * Returns the normalized column for the columnExpr (if any)
- * The column expression must be a column otherwise null is returned
- * @return the normalized column or null
- */
- @SuppressWarnings("unchecked")
- public static <T extends ColumnExpr> T getNormalizedColumn(ColumnExpr columnExpr)
- {
- // must be a column
- if (!isColumn(columnExpr))
- return null;
- // return attribute
- return (T)instance.getColumnAttribute(columnExpr, Column.COLATTR_NORMCOLUMN);
- }
-
- /**
- * Sets a normalized columnExpr for this columnExpr
- * @param sourceColumn the column
- * @param normalizedColumn the normalized columnExpr
- * @return returns the sourceColumn
- */
- public static <T extends Column> T setNormalizedColumn(T sourceColumn, ColumnExpr normalizedColumn)
- {
- return sourceColumn.setAttribute(Column.COLATTR_NORMCOLUMN, normalizedColumn);
- }
-
/*
* Implementations
*/
diff --git a/empire-db/src/main/java/org/apache/empire/db/DBColumn.java b/empire-db/src/main/java/org/apache/empire/db/DBColumn.java
index 22c7099e..b69a6460 100644
--- a/empire-db/src/main/java/org/apache/empire/db/DBColumn.java
+++ b/empire-db/src/main/java/org/apache/empire/db/DBColumn.java
@@ -20,8 +20,10 @@ package org.apache.empire.db;
import java.util.Collections;
import java.util.Set;
+import java.util.regex.Pattern;
import org.apache.empire.commons.Attributes;
+import org.apache.empire.commons.ObjectUtils;
import org.apache.empire.commons.Options;
import org.apache.empire.commons.StringUtils;
import org.apache.empire.data.Column;
@@ -29,8 +31,11 @@ import org.apache.empire.data.DataType;
import org.apache.empire.data.Entity;
import org.apache.empire.db.exceptions.DatabaseNotOpenException;
import org.apache.empire.db.expr.column.DBAliasExpr;
+import org.apache.empire.db.expr.column.DBFuncExpr;
import org.apache.empire.db.expr.set.DBSetExpr;
import org.apache.empire.dbms.DBMSHandler;
+import org.apache.empire.exceptions.InvalidArgumentException;
+import org.apache.empire.exceptions.NotSupportedException;
import org.apache.empire.exceptions.ObjectNotValidException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -390,8 +395,9 @@ public abstract class DBColumn extends DBColumnExpr
: Collections.EMPTY_SET);
}
- /**
- * @see DBColumnExpr#getOptions()
+ /*
+ * (non-Javadoc)
+ * @see org.apache.empire.db.DBColumnExpr#getOptions()
*/
@Override
public Options getOptions()
@@ -401,17 +407,15 @@ public abstract class DBColumn extends DBColumnExpr
/**
* Returns true if an enum type has been set for this column
- * <P>
* @return true if an enum type has been set for this column or false otherwise
*/
public final boolean isEnum()
{
return (getEnumType()!=null);
}
-
+
/**
* Returns the enum type for this column
- * <P>
* @return the enum type
*/
@Override
@@ -421,6 +425,10 @@ public abstract class DBColumn extends DBColumnExpr
return (Class<Enum<?>>)getAttribute(COLATTR_ENUMTYPE);
}
+ /**
+ * Returns the java type for this column
+ * @return the java type
+ */
@Override
public Class<?> getJavaType()
{
@@ -430,6 +438,131 @@ public abstract class DBColumn extends DBColumnExpr
// default
return super.getJavaType();
}
+
+ /**
+ * Returns whether or not a columnExpr is case sensitive
+ * If not explicitly set, the case sensitivity is true for all text fields (VARCHAR, CLOB) except if an EnumType is set.
+ * @return true if the columnExpr is case sensitive or false if not
+ */
+ public boolean isCaseSensitive()
+ {
+ // only for text expressions
+ if (!getDataType().isText())
+ return false;
+ // check attribute
+ Object value = getAttribute(Column.COLATTR_CASESENSITIVE);
+ if (value!=null)
+ return ObjectUtils.getBoolean(value);
+ // default is true for VARCHAR and CLOB except if Options or EnumType are set
+ return (getOptions()==null && getEnumType()==null);
+ }
+
+ /**
+ * Sets the case sensitivity of the columnExpr
+ * @param caseSensitiv the character casing. This may be true, false or null (default)
+ * @return self (this)
+ */
+ @SuppressWarnings("unchecked")
+ public <T extends DBColumn> T setCaseSensitive(Boolean caseSensitiv)
+ {
+ if (!getDataType().isText())
+ throw new NotSupportedException(this, "setCaseInsensitive");
+ // set now
+ setAttribute(Column.COLATTR_CASESENSITIVE, caseSensitiv);
+ return (T)this;
+ }
+
+ /**
+ * Sets the case sensitivity of the column to insensitive
+ * Text columns are case sensitive by default
+ * @return self (this)
+ */
+ public final <T extends DBColumn> T setCaseInsensitive()
+ {
+ return setCaseSensitive(false);
+ }
+
+ /**
+ * Returns the maximum allowed value
+ * @return the minimum length
+ */
+ public Pattern getRegExPattern()
+ {
+ return (Pattern)getAttribute(Column.COLATTR_REGEXP);
+ }
+
+ /**
+ * Set the regular expression to validate the columnExpr value
+ * @param regex the regular expression
+ * @return self (this)
+ */
+ @SuppressWarnings("unchecked")
+ public <T extends DBColumn> T setRegExPattern(String regex)
+ {
+ setAttribute(Column.COLATTR_REGEXP, Pattern.compile(regex));
+ return (T)this;
+ }
+
+ /**
+ * Returns the normalized column for the columnExpr (if any)
+ * @return the normalized column or null
+ */
+ public DBColumnExpr getNormalizedColumn()
+ { // return attribute
+ return (DBColumn)getAttribute(Column.COLATTR_NORMCOLUMN);
+ }
+
+ /**
+ * Sets a normalized columnExpr for this columnExpr
+ * @param normalizedColumn the normalized columnExpr
+ * @return self (this)
+ */
+ @SuppressWarnings("unchecked")
+ public <T extends Column> T setNormalizedColumn(DBColumnExpr normalizedColumn)
+ {
+ setAttribute(Column.COLATTR_NORMCOLUMN, normalizedColumn);
+ return (T)this;
+ }
+
+ /**
+ * Returns the sort expression for a given column
+ * If no sort expression is explicitly set then the column itself is returned
+ * The returned expression should be assigned to an DBCommand.orderBy() function.
+ *
+ * @return the sort expression or the column itself if not sort expression is set
+ */
+ public DBColumnExpr getSortExpr()
+ {
+ Object value = getAttribute(Column.COLATTR_SORTEXPRESSION);
+ // create a sort expression
+ if (value instanceof DBColumnExpr)
+ { // return expression
+ return ((DBColumnExpr)value);
+ }
+ else if ((value instanceof String) && ((String)value).indexOf('?')>=0)
+ { // create a sort function expression
+ String sortFunctionTemplate = StringUtils.toString(value);
+ return new DBFuncExpr(this, sortFunctionTemplate, null, false, getDataType());
+ }
+ else if (value!=null)
+ { // unknown value
+ log.warn("Invalid value for {}: {}", Column.COLATTR_SORTEXPRESSION, value);
+ }
+ // not changed
+ return this;
+ }
+
+ /**
+ * Sets a sort function expression for a given column
+ * @param sortExpression the expression which to use for sorting
+ * @return self (this)
+ */
+ @SuppressWarnings("unchecked")
+ public <T extends DBColumn> T setSortExpr(DBColumnExpr sortExpression)
+ { // set sort expression
+ setAttribute(Column.COLATTR_SORTEXPRESSION, sortExpression);
+ return (T)this;
+ }
/**
* Creates and returns a sql-expression that maps enum values by name or ordinal to their string representation
@@ -456,6 +589,23 @@ public abstract class DBColumn extends DBColumnExpr
return super.decodeSort(getEnumType(), defaultToEnd);
}
+ /**
+ * Sets a sort function template for a given column
+ * @param column the column for which to set the sort expression
+ * @param sortFunctionTemplate the template which must contain a ? which will be replaced with the column name
+ * @return return the column
+ */
+ @SuppressWarnings("unchecked")
+ public <T extends DBColumn> T setSortExpr(String sortFunctionTemplate)
+ {
+ // check param
+ if (sortFunctionTemplate!=null && sortFunctionTemplate.indexOf('?')<0)
+ throw new InvalidArgumentException("sortFunctionTemplate", sortFunctionTemplate);
+ // set sort expression
+ setAttribute(Column.COLATTR_SORTEXPRESSION, sortFunctionTemplate);
+ return (T)this;
+ }
+
/**
* Creates and returns a new DBSetExpr object.
*
diff --git a/empire-db/src/main/java/org/apache/empire/db/DBDatabase.java b/empire-db/src/main/java/org/apache/empire/db/DBDatabase.java
index 6a6c537b..69aec6b1 100644
--- a/empire-db/src/main/java/org/apache/empire/db/DBDatabase.java
+++ b/empire-db/src/main/java/org/apache/empire/db/DBDatabase.java
@@ -35,6 +35,8 @@ import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
import org.apache.empire.commons.DateUtils;
import org.apache.empire.commons.ObjectUtils;
@@ -1208,11 +1210,8 @@ public abstract class DBDatabase extends DBObject
// check enum
if (value instanceof Enum<?>)
break; // Convert later...
- // check length
- if (value.toString().length() > (int)column.getSize())
- {
- throw new FieldValueTooLongException(column);
- }
+ // validate
+ value = validateString(column, value.toString());
break;
default:
@@ -1266,6 +1265,24 @@ public abstract class DBDatabase extends DBObject
return n;
}
+ protected String validateString(DBTableColumn column, String value)
+ {
+ // check length
+ if (value.length() > (int)column.getSize())
+ {
+ throw new FieldValueTooLongException(column);
+ }
+ // check regex
+ Pattern pattern = column.getRegExPattern();
+ if (pattern!=null)
+ {
+ Matcher matcher = pattern.matcher(value);
+ if (!matcher.matches())
+ throw new FieldIllegalValueException(column, value);
+ }
+ return value;
+ }
+
/**
* Creates a SQL case expression
* in the form "case when [condition] then [trueValue] else [falseValue] end"