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"