Changeset 4071

Timestamp:

Dec 19, 2007, 2:02:39 PM (15 years ago)

Author:

Martin Svensson

Message:

References #762 The functionality is now completely implemented. It needs to be documented before this ticket can be closed.

Location:

trunk/src

Files:

• clients/web/net/sf/basedb/clients/web/Base.java (modified) (5 diffs)
• core/net/sf/basedb/core/AnnotationSimpleRestriction.java (modified) (5 diffs)
• core/net/sf/basedb/core/Operator.java (modified) (5 diffs)
• core/net/sf/basedb/core/PropertyFilter.java (modified) (8 diffs)
• core/net/sf/basedb/core/query/Restrictions.java (modified) (2 diffs)

trunk/src/clients/web/net/sf/basedb/clients/web/Base.java

@@ -568 +568 @@
                       (isList ? Operator.IN : Operator.EQ);
                 value = value.substring(1);
-              }
+              }             
               if ("".equals(value)) value = null;
               if (valueType == Type.DATE && value != null)
@@ -577 +577 @@
                 try
                 {
-                  Date d = dateFormatter != null ? dateFormatter.parseString(value) : DateUtil.parseString(value);
-                  value = d == null ? null : Long.toString(d.getTime());
+                  if (isList)
+                  { 
+                    String[] dates = value.split("\\" + filter.getValueSeparator());
+                    value = "";
+                    boolean addSeparator = false;
+                    for (String s : dates)
+                    {
+                      Date d = dateFormatter != null ? dateFormatter.parseString(s) : DateUtil.parseString(s);                      
+                      if (d != null)
+                      {                       
+                        value += (addSeparator ? filter.getValueSeparator() : "") + Long.toString(d.getTime());
+                        addSeparator = true;
+                      }
+                    }
+                    value = value.length() == 0 ? null : value;                   
+                  }
+                  else
+                  {
+                    Date d = dateFormatter != null ? dateFormatter.parseString(value) : DateUtil.parseString(value);
+                    value = d == null ? null : Long.toString(d.getTime());
+                  }
                 }
                 catch (Throwable t)
@@ -675 +694 @@
           // Dates are stored as long time values; reformat according to date formatter
           // or as yyyy-MM-dd if no formatter is specified
-          Date d = new Date(Long.parseLong(value));
-          if (dateFormatter != null)
+          if (!op.isListOperator())
           {
-            value = dateFormatter.format(d);
+            Date d = new Date(Long.parseLong(value));
+            if (dateFormatter != null)
+            {
+              value = dateFormatter.format(d);
+            }
+            else
+            {
+              value = DateUtil.formatDate(d);
+            }
           }
           else
           {
-            value = DateUtil.formatDate(d);
+            String[] dates = value.split("\\" + filter.getValueSeparator());
+            boolean addSeparator = false;
+            for (String s : dates)
+            {
+              Date d = new Date(Long.parseLong(s));
+              value = addSeparator ? value + filter.getValueSeparator() : "";
+              if (dateFormatter != null)
+              {
+                value += dateFormatter.format(d);               
+              }
+              else
+              {
+                value += DateUtil.formatDate(d); 
+              }
+              addSeparator = true;
+            }
           }
         }
@@ -692 +733 @@
         result = "=";
       }
-      else if (op == Operator.NEQ || op == Operator.NOTLIKE)
+      else if (op == Operator.NEQ || op == Operator.NOTLIKE || 
+          op == Operator.NOTLIKE_IN || op == Operator.NOTIN)
       {
         result = "<>";
@@ -711 +753 @@
       {
         result = "<=";
+      }
+      else if (op == Operator.EQ && value.contains(filter.getValueSeparator()))
+      {
+        result = "==";
       }
       result += value == null ? "" : value;

trunk/src/core/net/sf/basedb/core/AnnotationSimpleRestriction.java

@@ -27 +27 @@
 
 import net.sf.basedb.core.query.Query;
+
+import java.util.List;
 
 import org.hibernate.SQLQuery;
@@ -44 +46 @@
   private final Operator operator;
   private final Object value;
+  private final List<Object> values;
 
   /**
@@ -94 +97 @@
     this.operator = operator;
     this.value = value;
+    this.values = null;
   }
 
@@ -144 +148 @@
     this.operator = operator;
     this.value = value;
+    this.values = null;
+  }
+  
+  /**
+    Creates a new annotation restriction for a specific <code>valueType</code>.
+    The restriction is with a list of values.
+    
+    @param alias The alias of a joined item where the annotations are
+      located or null to use the root entity of the query
+      @param annotationTypeId the id of the annotation type to use in the query
+    @param valueType the type of values for annotations
+      @param operator The operator, it must be one of the expression
+      operators, EQ, NEQ, etc., not a boolean operator, AND, OR, etc.
+      @param values The list of values that should be used in the query, they must be of the 
+      correct value type for the annotation as defined by the 
+      {@link AnnotationType#getValueType()} property.
+      @param includeInheriting TRUE if items inheriting the annotation should be returned by the query, FALSE otherwise
+      @throws InvalidDataException If any of the parameters are null
+      or not follow the rules above
+    @since 2.5
+  */
+  public AnnotationSimpleRestriction(String alias, int annotationTypeId, Type valueType, Operator operator, List<Object> values, boolean includeInheriting)
+    throws InvalidDataException
+  {
+    super(alias, annotationTypeId, valueType, includeInheriting);
+    if (operator == null) throw new InvalidUseOfNullException("operator");
+    if (values == null) throw new InvalidUseOfNullException("values");
+    if (!operator.isExpressionOperator())
+    {
+      throw new InvalidDataException("Invalid operator for expression: "+operator);
+    }
+    for (Object obj : values)
+    {
+      if (!valueType.isCorrectType(obj))
+      {
+        throw new InvalidDataException("Value '"+obj+"' is a "+
+          obj.getClass()+", not a "+valueType);
+      }
+    }
+    this.operator = operator;
+    this.values = values;
+    this.value = null;
   }
   
@@ -153 +199 @@
     throws BaseException
   {
-    org.hibernate.dialect.Dialect dialect = HibernateUtil.getDialect();
-    return "v."+dialect.openQuote()+"value"+dialect.closeQuote()+" "+operator.getSqlSymbol()+" :value";
+    org.hibernate.dialect.Dialect dialect = HibernateUtil.getDialect();   
+    String restriction = null;
+    if (!operator.isListOperator())
+    {
+      restriction = "v."+dialect.openQuote()+"value"+dialect.closeQuote()+" "+operator.getSqlSymbol()+ " :value";
+    }
+    else
+    {
+      if (operator == Operator.IN || operator == Operator.NOTIN)
+      {
+        restriction = "v."+dialect.openQuote()+"value"+dialect.closeQuote()+" "+operator.getSqlSymbol()+ " (:value)";
+      }
+      else if (operator == Operator.NOTLIKE_IN || operator == Operator.LIKE_IN)
+      {
+        boolean isFirst = true;
+        restriction = "(";
+        for (Object obj : values)
+        {
+          restriction += isFirst ? "" : 
+            operator == Operator.NOTLIKE_IN ? " AND ": " OR ";
+          restriction += "v."+dialect.openQuote()+"value"+dialect.closeQuote()+" "+operator.getSqlSymbol()+ " :value"+System.identityHashCode(obj);
+          isFirst = false;
+        }
+        restriction += ")"; 
+      }
+    }
+    return restriction;
   }
   
   void setRestrictionParameters(SQLQuery query)
   {
-    query.setParameter("value", value);
+    if (!operator.isListOperator())
+    {
+      query.setParameter("value", value);
+    }
+    else
+    {
+      if (operator == Operator.IN || operator == Operator.NOTIN)
+      {
+        query.setParameterList("value", values);
+      }
+      else if (operator == Operator.LIKE_IN || operator == Operator.NOTLIKE_IN)
+      {
+        for (Object obj : values)
+        {
+          query.setParameter("value"+System.identityHashCode(obj), obj);
+        }
+      }
+    }
+    
   }
   // -----------------------------------------

trunk/src/core/net/sf/basedb/core/Operator.java

@@ -204 +204 @@
   
   /**
-    @since 2.5
+    @since 2.6
    */
   IN(12, "IN", "IN", true, true)
@@ -223 +223 @@
   
   /**
-    @since 2.5
+    @since 2.6
    */
   NOTIN(13, "NOT IN", "NOT IN", true, true)
@@ -242 +242 @@
   
   /**
-    @since 2.5
+    @since 2.6
    */
   LIKE_IN(14, "LIKE", "LIKE", true, true)
@@ -261 +261 @@
 
   /**
-    @since 2.5
-   */
-  NOTLIKE_IN(15, "LIKE", "LIKE", true, true)
+    @since 2.6
+   */
+  NOTLIKE_IN(15, "NOT LIKE", "NOT LIKE", true, true)
   {
     public Restriction getRestriction(Expression lvalue, Expression rvalue)
@@ -275 +275 @@
       throws InvalidDataException
     {
-      return Restrictions.not(Restrictions.like_in(lvalue, rvalues));
+      return Restrictions.notLike_in(lvalue, rvalues);
     }
   };

trunk/src/core/net/sf/basedb/core/PropertyFilter.java

@@ -52 +52 @@
 {
 
+  /**
+    The string/characters used as a separator in a string with more then one filter values.
+   */
+  private final String value_separator = "|";
+  
   private final String property;
   private Type valueType;
   private Operator operator;
   private String value;
-
+  
   
   /**
@@ -187 +192 @@
     Splits the value string at each "|" and creates
     a list with objects from the substrings that were found.
-    @return A list with objects.
+    @return A list with objects, or null if splitting string of values returns null.
     @throws InvalidDataException If any of the string values can't be parsed.
     @sine 2.5 
@@ -193 +198 @@
   public List<Object> getValuesAsObjects()
   {
-    String[] values = value.split("|");
+    String[] values = value.split("\\"+getValueSeparator());
+    if (values == null) return null;
     List<Object> objects = new ArrayList<Object>(values.length);
     for (String v : values)
@@ -254 +260 @@
       if (operator.isListOperator())
       {
-        
+        restriction = new AnnotationSimpleRestriction(alias,annotationTypeId, getValueType(), getOperator(), getValuesAsObjects(), searchInherited);
       }
       else
@@ -265 +271 @@
     {
       String parameterName = "p" + System.identityHashCode(this);
-      Expression parameter = getValue() == null ? null : 
+      Expression parameter = (getValue() == null || operator.isListOperator()) ? null : 
         Expressions.parameter(parameterName, getValueAsObject(), getValueType());
 
@@ -306 +312 @@
               // property >= date + 24H
               restriction = Restrictions.gteq(propertyExpression, parameterPlus24H);
-            }
+            }           
           }
           else 
@@ -320 +326 @@
                   Expressions.parameter(parameterName+"24h", filterPlus24H, Type.DATE);
               Expression dateParameter = Expressions.parameter(parameterName, obj, getValueType());
-              if (operator == Operator.IN)
-              {
-                restrictions.add(Restrictions.between(propertyExpression, dateParameter, parameterPlus24H));
-              }
-              else if (operator == Operator.NOTIN)
-              {
-                restrictions.add(Restrictions.not(Restrictions.between(propertyExpression, dateParameter, parameterPlus24H)));
-              }
-            }
-            restriction = Restrictions.or(restrictions.toArray(new Restriction[restrictions.size()]));
+              restrictions.add(Restrictions.between(propertyExpression, dateParameter, parameterPlus24H));
+            }
+            if (operator == Operator.IN) 
+            {
+              restriction = Restrictions.or(restrictions.toArray(new Restriction[restrictions.size()]));
+            }
+            else if (operator == Operator.NOTIN)
+            {
+              restriction = Restrictions.not(Restrictions.or(restrictions.toArray(new Restriction[restrictions.size()])));
+            }
           }
-          
         }
         if (restriction == null)
@@ -365 +370 @@
     String value = getValue();
     Expression parameter = null;
+    List<Expression> parameters = null;
     // Experimental - allows expressions like: >ch1
     if (value != null && (valueType == Type.FLOAT || valueType == Type.DOUBLE || valueType == Type.INT || valueType == Type.LONG))
     {
-      if (value.matches("^ch\\d+$"))
+      if (!getOperator().isListOperator() && value.matches("^ch\\d+$"))
       {
         int channel = Integer.parseInt(value.substring(2));
         parameter = Dynamic.column(VirtualColumn.channel(channel));
       }
-    }
-    if (parameter == null)
-    {
-      parameter = value == null ? null : Expressions.parameter(parameterName, getValueAsObject());
-    }
-    restriction = operator.getRestriction(propertyExpression, parameter);
+      else if (getOperator().isListOperator())
+      {
+        String[] values = value.split("\\"+getValueSeparator());
+        for (String s : values)
+        {
+          if (s.matches("^ch\\d+$"))
+          {
+            int channel = Integer.parseInt(s.substring(2));
+            if (parameters == null)
+            {
+              parameters = new ArrayList<Expression>();
+            }
+            parameters.add(Dynamic.column(VirtualColumn.channel(channel)));
+          }
+        }
+      }     
+    }
+    if (parameter == null && parameters == null)
+    {
+      if (getOperator().isListOperator())
+      {
+        List<Object> objects = getValuesAsObjects();        
+        parameters = objects == null ? null : new ArrayList<Expression>(objects.size());
+        for (Object obj : objects)
+        {
+          parameterName = "p" + System.identityHashCode(obj);
+          parameters.add(Expressions.parameter(parameterName,obj));
+        }       
+      }
+      else
+      {
+        parameter = value == null ? null : Expressions.parameter(parameterName, getValueAsObject());
+      }
+    }
+    if (parameters != null)
+    {
+      restriction = operator.getRestriction(propertyExpression, parameters.toArray(new Expression[parameters.size()]));
+    }
+    else
+    {
+      restriction = operator.getRestriction(propertyExpression, parameter);
+    }
     return restriction;
   }
+  
+  public String getValueSeparator()
+  {
+    return value_separator;
+  }
 
 }

trunk/src/core/net/sf/basedb/core/query/Restrictions.java

@@ -256 +256 @@
   /**
     Check if one expression matches any expressions in an array:
-    (e1 LIKE e2) OR (e1 LIKE e3) OR ....
+    (e1 LIKE e2.1) OR (e1 LIKE e2.2) OR ....
     @param e1 The left expression
     @param e2 The array with expression to match against.
@@ -281 +281 @@
   
   /**
+    Check if one expression doesn't matches any of the expressions in an array.
+    (e1 NOT LIKE e2.1) AND (e1 NOT LIKE e2.2) AND...
+      @param e1 The left expression. Null is not allowed
+      @param e2 The array with expressions that shouldn't match. Values in the array can't be null.
+      @return The new restriction
+      @throws InvalidDataException If any of the required expressions are null.
+      @since 2.6
+   */
+  public static Restriction notLike_in(Expression e1, Expression...e2)
+  {
+    if (e1 == null) throw new InvalidUseOfNullException("e1");
+    int firstNull = getFirstNull(e2);
+    if (firstNull >= 0 || e2 == null)
+    {
+      throw new InvalidUseOfNullException("e2[" + firstNull + "]");
+    }
+    if (e2.length < 1) throw new InvalidDataException("'e2' must contain at least one element");
+    List<Restriction> restrictions = new ArrayList<Restriction>(e2.length);   
+    for (Expression e : e2)
+    {
+      restrictions.add(Restrictions.not(Restrictions.like(e1, e)));
+    }   
+    return Restrictions.and(restrictions.toArray(new Restriction[restrictions.size()]));
+  }
+  
+  /**
     Test if there is null in the array.
     @return The index of the first null element,