org.deegree.sqldialect.filter.AbstractWhereBuilder java code examples

protected StringBuilder getPreparedStatementDatasetIDs( AbstractWhereBuilder builder ) {
  StringBuilder getDatasetIDs = new StringBuilder( 300 );
  String rootTableAlias = builder.getAliasManager().getRootTableAlias();
  getDatasetIDs.append( "SELECT DISTINCT " );
  getDatasetIDs.append( rootTableAlias );
  getDatasetIDs.append( '.' );
  getDatasetIDs.append( idColumn );
  // for SELECT DISTINCT, all ORDER BY columns have to be SELECTed as well
  if ( builder.getOrderBy() != null ) {
    // hack to transform the ORDER BY column list in select list
    String orderColList = builder.getOrderBy().getSQL().toString();
    int i = 1;
    while ( orderColList.contains( " ASC" ) || orderColList.contains( "DESC" ) ) {
      orderColList = orderColList.replaceFirst( " ASC| DESC", " AS crit" + ( i++ ) );
    }
    getDatasetIDs.append( ',' );
    getDatasetIDs.append( orderColList );
  }
  return getDatasetIDs;
}

protected void getPSBody( AbstractWhereBuilder builder, StringBuilder getDatasetIDs ) {
  String rootTableAlias = builder.getAliasManager().getRootTableAlias();
  getDatasetIDs.append( " FROM " );
  getDatasetIDs.append( mainTable );
  getDatasetIDs.append( " " );
  getDatasetIDs.append( rootTableAlias );
  for ( PropertyNameMapping mappedPropName : builder.getMappedPropertyNames() ) {
    for ( Join join : mappedPropName.getJoins() ) {
      getDatasetIDs.append( " LEFT OUTER JOIN " );
      getDatasetIDs.append( join.getToTable() );
      getDatasetIDs.append( ' ' );
      getDatasetIDs.append( join.getToTableAlias() );
      getDatasetIDs.append( " ON " );
      getDatasetIDs.append( join.getSQLJoinCondition() );
    }
  }
  if ( builder.getWhere() != null ) {
    getDatasetIDs.append( " WHERE " );
    getDatasetIDs.append( builder.getWhere().getSQL() );
  }
}

protected SQLExpression toProtoSQL( Expression expr, boolean assertNotMultiValued )
            throws UnmappableException, FilterEvaluationException {
  SQLExpression sql = toProtoSQL( expr );
  if ( assertNotMultiValued ) {
    assertNotMultiValued( sql );
  }
  return sql;
}

  String ftTableAlias = wb.getAliasManager().getRootTableAlias();
  LOG.debug( "WHERE clause: " + wb.getWhere() );
  LOG.debug( "ORDER BY clause: " + wb.getOrderBy() );
  for ( PropertyNameMapping mappedPropName : wb.getMappedPropertyNames() ) {
    for ( Join join : mappedPropName.getJoins() ) {
      sql.append( " LEFT OUTER JOIN " );
  if ( wb.getWhere() != null ) {
    if ( blobMapping != null ) {
      sql.append( " AND " );
    sql.append( wb.getWhere().getSQL() );
  if ( wb.getOrderBy() != null ) {
    sql.append( " ORDER BY " );
    sql.append( wb.getOrderBy().getSQL() );
  if ( wb.getWhere() != null ) {
    for ( SQLArgument o : wb.getWhere().getArguments() ) {
      o.setArgument( stmt, i++ );
  if ( wb.getOrderBy() != null ) {
    for ( SQLArgument o : wb.getOrderBy().getArguments() ) {
      o.setArgument( stmt, i++ );
if ( wb.getPostFilter() != null ) {
  LOG.debug( "Applying in-memory post-filtering." );
  result = new FilteredFeatureInputStream( result, wb.getPostFilter() );

AbstractWhereBuilder wb = getWhereBuilder( ft, filter, query.getSortProperties(), conn );
if ( wb.getPostFilter() != null ) {
  LOG.debug( "Filter not fully mappable to WHERE clause. Need to iterate over all features to determine count." );
  hits = queryByOperatorFilter( query, ftName, filter ).count();
} else {
  StringBuilder sql = new StringBuilder( "SELECT " );
  if ( wb.getWhere() == null ) {
    sql.append( "COUNT(*) FROM " );
    sql.append( ftMapping.getFtTable() );
    sql.append( "COUNT(*) FROM (SELECT DISTINCT " );
    String ftTableAlias = wb.getAliasManager().getRootTableAlias();
    for ( PropertyNameMapping mappedPropName : wb.getMappedPropertyNames() ) {
      for ( Join join : mappedPropName.getJoins() ) {
        sql.append( " LEFT OUTER JOIN " );
    LOG.debug( "WHERE clause: " + wb.getWhere() );
    if ( wb.getWhere() != null ) {
      sql.append( " WHERE " );
      sql.append( wb.getWhere().getSQL() );
  if ( wb.getWhere() != null ) {
    for ( SQLArgument o : wb.getWhere().getArguments() ) {
      o.setArgument( stmt, i++ );

if ( builder.getOrderBy() != null ) {
  idSelect.append( " ORDER BY " );
  idSelect.append( builder.getOrderBy().getSQL() );
if ( builder.getOrderBy() != null ) {
  outerSelect.append( " ORDER BY " );
  String sortCols = builder.getOrderBy().getSQL().toString();
  String rootTableQualifier = builder.getAliasManager().getRootTableAlias() + ".";
  int columnCount = StringUtils.count( sortCols, "," ) + 1;
  int rootAliasCount = StringUtils.count( sortCols, rootTableQualifier );
  String colRegEx = builder.getAliasManager().getRootTableAlias() + ".\\S+";
  for ( int i = 1; i <= columnCount; i++ ) {
    sortCols = sortCols.replaceFirst( colRegEx, "crit" + i );
if ( builder.getWhere() != null ) {
  for ( SQLArgument o : builder.getWhere().getArguments() ) {
    o.setArgument( preparedStatement, i++ );
    arguments.add( o.getValue() );
if ( builder.getOrderBy() != null ) {
  for ( SQLArgument o : builder.getOrderBy().getArguments() ) {
    o.setArgument( preparedStatement, i++ );
    arguments.add( o.getValue() );

stmt = connection.prepareStatement( header.toString() );
int i = 1;
if ( builder.getWhere() != null ) {
  for ( SQLArgument o : builder.getWhere().getArguments() ) {
    o.setArgument( stmt, i++ );
if ( builder.getOrderBy() != null ) {
  for ( SQLArgument o : builder.getOrderBy().getArguments() ) {
    o.setArgument( stmt, i++ );

getDatasetIDs.append( "SELECT " );
getDatasetIDs.append( "COUNT( DISTINCT(" );
getDatasetIDs.append( builder.getAliasManager().getRootTableAlias() );
getDatasetIDs.append( "." );
getDatasetIDs.append( idColumn );
if ( builder.getWhere() != null ) {
  for ( SQLArgument o : builder.getWhere().getArguments() ) {
    o.setArgument( preparedStatement, i++ );
    arguments.add( o.getValue() );

public static String repairAliasesInWhereClause( AbstractWhereBuilder builder, List<Join> usedJoins,
                         List<Join> redundantJoins ) {
  String whereClause = builder.getWhere().getSQL().toString();
  for ( Join redundantJoin : redundantJoins ) {
    Join usedJoin = getEquivalentJoin( redundantJoin, usedJoins );
    String usedAlias = usedJoin.getToTableAlias();
    String redundantAlias = redundantJoin.getToTableAlias();
    whereClause = whereClause.replace( redundantAlias, usedAlias );
  }
  return whereClause;
}

PropertyIsBetween propIsBetween = (PropertyIsBetween) op;
SQLOperationBuilder builder = new SQLOperationBuilder( BOOLEAN );
SQLExpression lower = toProtoSQL( propIsBetween.getLowerBoundary(), true );
SQLExpression expr = toProtoSQL( propIsBetween.getExpression(), true );
SQLExpression upper = toProtoSQL( propIsBetween.getUpperBoundary(), true );
inferType( lower, expr, upper );
builder.add( "(" );
addExpression( builder, lower, op.isMatchCase() );
builder.add( " <= " );
addExpression( builder, expr, op.isMatchCase() );
builder.add( " AND " );
addExpression( builder, expr, op.isMatchCase() );
builder.add( " <= " );
addExpression( builder, upper, op.isMatchCase() );
builder.add( ")" );
sqlOper = builder.toOperation();
SQLExpression param1 = toProtoSQL( propIsEqualTo.getParameter1() );
SQLExpression param2 = toProtoSQL( propIsEqualTo.getParameter2() );
if ( !param1.isMultiValued() && !param2.isMultiValued() ) {
  inferType( param1, param2 );
  SQLOperationBuilder builder = new SQLOperationBuilder( BOOLEAN );
  addExpression( builder, param1, op.isMatchCase() );
  builder.add( " = " );
  addExpression( builder, param2, op.isMatchCase() );
  sqlOper = builder.toOperation();
} else {
  Expression literal = propIsEqualTo.getParameter2();

boolean isConstant = appendParamsFromFunction( function, params );
SQLFunctionProvider sqlFunction = SQLFunctionManager.getFunctionProvider( function.getName() );
if ( sqlFunction != null ) {
} else if ( isConstant ) {
  TypedObjectNode value = evaluateFunction( function, params );
  if ( value instanceof Geometry ) {
    return new SQLArgument( (Geometry) value, null );

if ( wb.getWhere() != null ) {
  idSelect.append( " WHERE " ).append( wb.getWhere().getSQL() );
if ( wb.getOrderBy() != null ) {
  idSelect.append( " ORDER BY " );
  idSelect.append( wb.getOrderBy().getSQL() );
if ( wb.getWhere() != null ) {
  for ( SQLArgument argument : wb.getWhere().getArguments() ) {
    argument.setArgument( stmt, i++ );
if ( wb.getOrderBy() != null ) {
  for ( SQLArgument argument : wb.getOrderBy().getArguments() ) {
    argument.setArgument( stmt, i++ );

  OperatorFilter bboxFilter = new OperatorFilter( query.getPrefilterBBox() );
  wb = getWhereBuilderBlob( bboxFilter, conn );
  LOG.debug( "WHERE clause: " + wb.getWhere() );
String alias = wb != null ? wb.getAliasManager().getRootTableAlias() : "X1";
if ( wb != null ) {
  sql.append( " AND " );
  sql.append( wb.getWhere().getSQL() );
stmt.setShort( i++, getSchema().getFtId( ftName ) );
if ( wb != null ) {
  for ( SQLArgument o : wb.getWhere().getArguments() ) {
    o.setArgument( stmt, i++ );

  first = false;
if ( wb.getWhere() != null ) {
  innerSelect.append( " WHERE " ).append( wb.getWhere().getSQL() );
if ( wb.getWhere() != null ) {
  for ( SQLArgument argument : wb.getWhere().getArguments() ) {
    argument.setArgument( stm, i++ );

  OperatorFilter bboxFilter = new OperatorFilter( query.getPrefilterBBox() );
  wb = getWhereBuilderBlob( bboxFilter, conn );
  LOG.debug( "WHERE clause: " + wb.getWhere() );
String alias = wb != null ? wb.getAliasManager().getRootTableAlias() : "X1";
  for ( PropertyNameMapping mappedPropName : wb.getMappedPropertyNames() ) {
    for ( Join join : mappedPropName.getJoins() ) {
      sql.append( " LEFT OUTER JOIN " );
if ( wb != null ) {
  sql.append( " AND " );
  sql.append( wb.getWhere().getSQL() );
  for ( SQLArgument o : wb.getWhere().getArguments() ) {
    o.setArgument( stmt, i++ );

for ( final short ftId2 : ftId ) {
  stmt.setShort( argIdx++, ftId2 );
  if ( blobWb != null && blobWb.getWhere() != null ) {
    for ( SQLArgument o : blobWb.getWhere().getArguments() ) {
      o.setArgument( stmt, argIdx++ );

  first = false;
if ( wb.getWhere() != null ) {
  sql.append( " WHERE " ).append( wb.getWhere().getSQL() );
if ( wb.getWhere() != null ) {
  for ( SQLArgument argument : wb.getWhere().getArguments() ) {
    argument.setArgument( stmt, i++ );

Javadoc

Base class for creating SQL predicates from Filter expressions. Such an expression restricts an SQL ResultSet to those rows that contain objects that match the given filter. Also handles the creation of ORDER BY clauses.

Note that the generated WHERE and ORDER-BY expressions are sometimes not sufficient to guarantee that a ResultSet only contains the targeted objects and/or keeps the requested order. This happens when the ValueReferences used in the filter/sort criteria are not mappable to columns in the database or the contained XPath expressions are not mappable to an equivalent SQL expression. In these cases, one or both of the methods #getPostFilter()/ #getPostSortCriteria() return not null and the objects extracted from the corresponding ResultSet must be filtered/sorted in memory to guarantee the requested constraints/order.

TODO: Implement partial backend filtering / sorting. Currently, filtering / sorting is performed completely by the database or by the post filter / criteria (if any property name has been encountered that could not be mapped).

Most used methods

getOrderBy
Returns the expression for the SQL-ORDER-BY clause.
getWhere
Returns the expression for the SQL-WHERE clause.
getAliasManager
Returns the TableAliasManager that keeps track of the used table aliases. The returned manager may a
getMappedPropertyNames
Returns the mappings of all ValueReferences from the filter / sort criteria that have been mapped to
addExpression
appendParamsFromFunction
assertNotMultiValued
Ensures that the given SQLExpression is not an SQLExpression that is multi-valued.
buildIsLike
evaluateFunction
getPostFilter
Returns a Filter that contains all constraints from the input filter that could not be expressed in
getPostSortCriteria
Returns the sort criteria that contains all parts from the input sort criteria that could not be exp
inferType

Popular in Java

Reading from database using SQL prepared statement
setContentView (Activity)
putExtra (Intent)
compareTo (BigDecimal)
RandomAccessFile (java.io)
Allows reading from and writing to a file in a random-access manner. This is different from the uni-
URL (java.net)
A Uniform Resource Locator that identifies the location of an Internet resource as specified by RFC
MessageDigest (java.security)
Uses a one-way hash function to turn an arbitrary number of bytes into a fixed-length byte sequence.
ResultSet (java.sql)
An interface for an object which represents a database table entry, returned as the result of the qu
LinkedHashMap (java.util)
LinkedHashMap is an implementation of Map that guarantees iteration order. All optional operations a
BlockingQueue (java.util.concurrent)
A java.util.Queue that additionally supports operations that wait for the queue to become non-empty
Top Sublime Text plugins

How to useAbstractWhereBuilder in org.deegree.sqldialect.filter

Best Java code snippets using org.deegree.sqldialect.filter.AbstractWhereBuilder (Showing top 17 results out of 315)

How to use
AbstractWhereBuilder
in
org.deegree.sqldialect.filter