| 
 | ||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
| Packages that use Expression | |
|---|---|
| org.apache.openjpa.jdbc.kernel.exps | OpenJPA-JDBC Expression Tree | 
| org.apache.openjpa.kernel.exps | OpenJPA Expression Tree | 
| org.apache.openjpa.kernel.jpql | JPA Query Language Support | 
| org.apache.openjpa.persistence.criteria | OpenJPA Criteria Query | 
| Uses of Expression in org.apache.openjpa.jdbc.kernel.exps | 
|---|
| Subinterfaces of Expression in org.apache.openjpa.jdbc.kernel.exps | |
|---|---|
| (package private)  interface | ExpAn Expression represents a query ready for execution. | 
| Classes in org.apache.openjpa.jdbc.kernel.exps that implement Expression | |
|---|---|
| (package private)  class | CompareEqualExpressionCompares two values for equality. | 
| (package private)  class | ConstInstanceofExpressionTests whether a value is an instance of a class. | 
| (package private)  class | EmptyExpressionAn empty expression. | 
| (package private)  class | EqualTypeExpressionCompares two entity types. | 
| (package private)  class | ExtensionFilter listener that evaluates to a value. | 
| (package private)  class | InExpressionTests whether a value is IN a collection. | 
| (package private)  class | InKeyExpressionTests whether a value is IN a map key set. | 
| (package private)  class | InSubQExpressionTests whether a value is IN a subquery. | 
| (package private)  class | InValueExpressionTests whether a value is IN a map value collection. | 
| (package private)  class | IsNotEmptyExpressionTests whether the given value is not empty. | 
| (package private)  class | NotContainsExpressionNegates a contains expression using a subselect to make sure no elements meet the criteria. | 
| (package private)  class | NotEqualTypeExpressionCompares two entity types. | 
| Methods in org.apache.openjpa.jdbc.kernel.exps that return Expression | |
|---|---|
|  Expression | JDBCExpressionFactory.and(Expression exp1,
    Expression exp2) | 
|  Expression | JDBCExpressionFactory.asExpression(Value v) | 
|  Expression | JDBCExpressionFactory.bindKeyVariable(Value var,
                Value val) | 
|  Expression | JDBCExpressionFactory.bindValueVariable(Value var,
                  Value val) | 
|  Expression | JDBCExpressionFactory.bindVariable(Value var,
             Value val) | 
|  Expression | JDBCExpressionFactory.contains(Value map,
         Value arg) | 
|  Expression | JDBCExpressionFactory.containsKey(Value map,
            Value arg) | 
|  Expression | JDBCExpressionFactory.containsValue(Value map,
              Value arg) | 
|  Expression | JDBCExpressionFactory.emptyExpression() | 
|  Expression | JDBCExpressionFactory.endsWith(Value v1,
         Value v2) | 
|  Expression | JDBCExpressionFactory.equal(Value v1,
      Value v2) | 
|  Expression | JDBCExpressionFactory.greaterThan(Value v1,
            Value v2) | 
|  Expression | JDBCExpressionFactory.greaterThanEqual(Value v1,
                 Value v2) | 
|  Expression | JDBCExpressionFactory.isEmpty(Value val) | 
|  Expression | JDBCExpressionFactory.isInstance(Value val,
           Class c) | 
|  Expression | JDBCExpressionFactory.isNotEmpty(Value val) | 
|  Expression | JDBCExpressionFactory.lessThan(Value v1,
         Value v2) | 
|  Expression | JDBCExpressionFactory.lessThanEqual(Value v1,
              Value v2) | 
|  Expression | JDBCExpressionFactory.matches(Value v1,
        Value v2,
        String single,
        String multi,
        String esc) | 
|  Expression | JDBCExpressionFactory.not(Expression exp) | 
|  Expression | JDBCExpressionFactory.notEqual(Value v1,
         Value v2) | 
|  Expression | JDBCExpressionFactory.notMatches(Value v1,
           Value v2,
           String single,
           String multi,
           String esc) | 
|  Expression | JDBCExpressionFactory.or(Expression exp1,
   Expression exp2) | 
|  Expression | JDBCExpressionFactory.startsWith(Value v1,
           Value v2) | 
|  Expression | JDBCExpressionFactory.whenCondition(Expression exp,
              Value val) | 
|  Expression | JDBCExpressionFactory.whenScalar(Value val1,
           Value val2) | 
| Methods in org.apache.openjpa.jdbc.kernel.exps with parameters of type Expression | |
|---|---|
|  Expression | JDBCExpressionFactory.and(Expression exp1,
    Expression exp2) | 
|  void | HasContainsExpressionVisitor.enter(Expression exp) | 
|  Value | JDBCExpressionFactory.generalCaseExpression(Expression[] exp,
                      Value val) | 
| static boolean | HasContainsExpressionVisitor.hasContains(Expression exp) | 
|  Expression | JDBCExpressionFactory.not(Expression exp) | 
|  Expression | JDBCExpressionFactory.or(Expression exp1,
   Expression exp2) | 
|  Value | JDBCExpressionFactory.simpleCaseExpression(Value caseOperand,
                     Expression[] exp,
                     Value val1) | 
|  Expression | JDBCExpressionFactory.whenCondition(Expression exp,
              Value val) | 
| Uses of Expression in org.apache.openjpa.kernel.exps | 
|---|
| Classes in org.apache.openjpa.kernel.exps that implement Expression | |
|---|---|
| (package private)  class | AndExpressionAn expression that AND's two others together. | 
| (package private)  class | BindKeyVariableExpressionBindVariableExpressionfor map key sets. | 
| (package private)  class | BindValueVariableExpressionBindVariableExpressionfor map value collections. | 
| (package private)  class | BindVariableAndExpressionAny contains(var) expression must be followed by at least one AND clause using the variable 'var'. | 
| (package private)  class | BindVariableExpressionBinds a variable to a collection. | 
| (package private)  class | CompareExpressionExpression that compares two others. | 
| (package private)  class | ContainsExpressionTests that a Collection contains a value. | 
| (package private)  class | ContainsKeyExpressionTests that a Map key set contains a value. | 
| (package private)  class | ContainsValueExpressionTests that a Map value collection contains a value. | 
| (package private)  class | EndsWithExpressionExpression that compares two others. | 
| (package private)  class | EqualExpressionExpression that compares two others. | 
|  class | ExpAn in-memory representation of an Expression. | 
| (package private)  class | GreaterThanEqualExpressionExpression that compares two others. | 
| (package private)  class | GreaterThanExpressionExpression that compares two others. | 
| (package private)  class | InstanceofExpressionTests whether a value is an instance of a class. | 
| (package private)  class | IsEmptyExpressionExpression to test for an empty Collection. | 
| (package private)  class | LessThanEqualExpressionExpression that compares two others. | 
| (package private)  class | LessThanExpressionExpression that compares two others. | 
| (package private)  class | MatchesExpressionExpression that compares two others. | 
| (package private)  class | NotEqualExpressionExpression that compares two others. | 
| (package private)  class | NotExpressionAn expression that NOT's another. | 
| (package private)  class | OrExpressionAn expression that OR's two others together. | 
| (package private)  class | StartsWithExpressionExpression that compares two others. | 
| (package private)  class | ValExpressionBoolean value used as an expression. | 
|  class | WhenCondition | 
|  class | WhenScalar | 
| Fields in org.apache.openjpa.kernel.exps declared as Expression | |
|---|---|
|  Expression | QueryExpressions.filter | 
|  Expression | Context.from | 
|  Expression | QueryExpressions.having | 
| Methods in org.apache.openjpa.kernel.exps that return Expression | |
|---|---|
|  Expression | InMemoryExpressionFactory.and(Expression exp1,
    Expression exp2) | 
|  Expression | ExpressionFactory.and(Expression exp1,
    Expression exp2)Return the two expressions AND'd together. | 
|  Expression | InMemoryExpressionFactory.asExpression(Value v) | 
|  Expression | ExpressionFactory.asExpression(Value bool)Return the given value as an expression. | 
|  Expression | InMemoryExpressionFactory.bindKeyVariable(Value var,
                Value val) | 
|  Expression | ExpressionFactory.bindKeyVariable(Value var,
                Value map)Bind the given variable to the key set of the given map value. | 
|  Expression | InMemoryExpressionFactory.bindValueVariable(Value var,
                  Value val) | 
|  Expression | ExpressionFactory.bindValueVariable(Value var,
                  Value map)Bind the given variable to the value set of the given map value. | 
|  Expression | InMemoryExpressionFactory.bindVariable(Value var,
             Value val) | 
|  Expression | ExpressionFactory.bindVariable(Value var,
             Value coll)Bind the given variable to the given collection value. | 
|  Expression | InMemoryExpressionFactory.contains(Value v1,
         Value v2) | 
|  Expression | ExpressionFactory.contains(Value coll,
         Value arg)Return an expression representing the given condition. | 
|  Expression | InMemoryExpressionFactory.containsKey(Value v1,
            Value v2) | 
|  Expression | ExpressionFactory.containsKey(Value map,
            Value arg)Return an expression representing the given condition. | 
|  Expression | InMemoryExpressionFactory.containsValue(Value v1,
              Value v2) | 
|  Expression | ExpressionFactory.containsValue(Value map,
              Value arg)Return an expression representing the given condition. | 
|  Expression | InMemoryExpressionFactory.emptyExpression() | 
|  Expression | ExpressionFactory.emptyExpression()Return a blank expression; this is used when the filter is empty. | 
|  Expression | InMemoryExpressionFactory.endsWith(Value v1,
         Value v2) | 
|  Expression | ExpressionFactory.endsWith(Value str1,
         Value str2)Return whether the first string ends with the second. | 
|  Expression | InMemoryExpressionFactory.equal(Value v1,
      Value v2) | 
|  Expression | ExpressionFactory.equal(Value v1,
      Value v2)Return an expression representing the given condition. | 
|  Expression | InMemoryExpressionFactory.greaterThan(Value v1,
            Value v2) | 
|  Expression | ExpressionFactory.greaterThan(Value v1,
            Value v2)Return an expression representing the given condition. | 
|  Expression | InMemoryExpressionFactory.greaterThanEqual(Value v1,
                 Value v2) | 
|  Expression | ExpressionFactory.greaterThanEqual(Value v1,
                 Value v2)Return an expression representing the given condition. | 
|  Expression | InMemoryExpressionFactory.isEmpty(Value v1) | 
|  Expression | ExpressionFactory.isEmpty(Value target)Return an expression representing the given condition. | 
|  Expression | InMemoryExpressionFactory.isInstance(Value v1,
           Class c) | 
|  Expression | ExpressionFactory.isInstance(Value obj,
           Class c)Return whether the first value is an instance of the given class. | 
|  Expression | InMemoryExpressionFactory.isNotEmpty(Value v1) | 
|  Expression | ExpressionFactory.isNotEmpty(Value target)Return an expression representing the given condition. | 
|  Expression | InMemoryExpressionFactory.lessThan(Value v1,
         Value v2) | 
|  Expression | ExpressionFactory.lessThan(Value v1,
         Value v2)Return an expression representing the given condition. | 
|  Expression | InMemoryExpressionFactory.lessThanEqual(Value v1,
              Value v2) | 
|  Expression | ExpressionFactory.lessThanEqual(Value v1,
              Value v2)Return an expression representing the given condition. | 
|  Expression | InMemoryExpressionFactory.matches(Value v1,
        Value v2,
        String single,
        String multi,
        String esc) | 
|  Expression | ExpressionFactory.matches(Value str,
        Value regexp,
        String single,
        String multi,
        String escape)Return whether the string matches the matching pattern. | 
|  Expression | InMemoryExpressionFactory.not(Expression exp) | 
|  Expression | ExpressionFactory.not(Expression exp)Return the inverse of this expression. | 
|  Expression | InMemoryExpressionFactory.notEqual(Value v1,
         Value v2) | 
|  Expression | ExpressionFactory.notEqual(Value v1,
         Value v2)Return an expression representing the given condition. | 
|  Expression | InMemoryExpressionFactory.notMatches(Value v1,
           Value v2,
           String single,
           String multi,
           String esc) | 
|  Expression | ExpressionFactory.notMatches(Value str,
           Value regexp,
           String single,
           String multi,
           String escape)Return whether the string does not match the given pattern. | 
|  Expression | InMemoryExpressionFactory.or(Expression exp1,
   Expression exp2) | 
|  Expression | ExpressionFactory.or(Expression exp1,
   Expression exp2)Return the two expressions OR'd together. | 
|  Expression | InMemoryExpressionFactory.startsWith(Value v1,
           Value v2) | 
|  Expression | ExpressionFactory.startsWith(Value str1,
           Value str2)Return whether the first string starts with the second. | 
|  Expression | InMemoryExpressionFactory.whenCondition(Expression exp,
              Value val) | 
|  Expression | ExpressionFactory.whenCondition(Expression exp,
              Value val)Return a when condidional clause | 
|  Expression | InMemoryExpressionFactory.whenScalar(Value val1,
           Value val2) | 
|  Expression | ExpressionFactory.whenScalar(Value val1,
           Value val2)Return a when scalar_expression clause | 
| Methods in org.apache.openjpa.kernel.exps with parameters of type Expression | |
|---|---|
|  Expression | InMemoryExpressionFactory.and(Expression exp1,
    Expression exp2) | 
|  Expression | ExpressionFactory.and(Expression exp1,
    Expression exp2)Return the two expressions AND'd together. | 
|  void | ExpressionVisitor.enter(Expression exp)Enter an expression. | 
|  void | AbstractExpressionVisitor.enter(Expression exp) | 
|  void | ExpressionVisitor.exit(Expression exp)Leave an expression. | 
|  void | AbstractExpressionVisitor.exit(Expression exp) | 
|  Value | InMemoryExpressionFactory.generalCaseExpression(Expression[] exp,
                      Value val) | 
|  Value | ExpressionFactory.generalCaseExpression(Expression[] exp,
                      Value val)Return a general case expression | 
|  Expression | InMemoryExpressionFactory.not(Expression exp) | 
|  Expression | ExpressionFactory.not(Expression exp)Return the inverse of this expression. | 
|  Expression | InMemoryExpressionFactory.or(Expression exp1,
   Expression exp2) | 
|  Expression | ExpressionFactory.or(Expression exp1,
   Expression exp2)Return the two expressions OR'd together. | 
|  Value | InMemoryExpressionFactory.simpleCaseExpression(Value caseOperand,
                     Expression[] exp,
                     Value val) | 
|  Value | ExpressionFactory.simpleCaseExpression(Value caseOperand,
                     Expression[] exp,
                     Value val)Return a simple case expression | 
|  Expression | InMemoryExpressionFactory.whenCondition(Expression exp,
              Value val) | 
|  Expression | ExpressionFactory.whenCondition(Expression exp,
              Value val)Return a when condidional clause | 
| Uses of Expression in org.apache.openjpa.kernel.jpql | 
|---|
| Methods in org.apache.openjpa.kernel.jpql that return Expression | |
|---|---|
| protected  Expression | JPQLExpressionBuilder.evalFetchJoins(QueryExpressions exps) | 
| Uses of Expression in org.apache.openjpa.persistence.criteria | 
|---|
| Methods in org.apache.openjpa.persistence.criteria with parameters of type Expression | |
|---|---|
| (package private) static Expression | Expressions.and(ExpressionFactory factory,
    Expression e1,
    Expression e2) | 
| 
 | ||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||