public SQLOperation toOperation() { return new SQLOperation( particles ); } }
private SQLOperation getOperationFromBuilder( PropertyIsLike op, SQLExpression propName, String sqlEncoded ) { SQLOperationBuilder builder = new SQLOperationBuilder(); if ( !op.isMatchCase() ) { builder.add( "LOWER(" ); } builder.add( propName ); if ( op.isMatchCase() ) { builder.add( "::TEXT LIKE '" ); } else { builder.add( "::TEXT) LIKE '" ); } builder.add( sqlEncoded ); builder.add( "'" ); return builder.toOperation(); }
@Override public StringBuilder getSQL() { StringBuilder sb = new StringBuilder(); for ( Object particle : particles ) { if ( particle instanceof SQLExpression ) { sb.append( ( (SQLExpression) particle ).getSQL() ); } else { sb.append( particle ); } } return sb; }
@Override public List<SQLArgument> getArguments() { List<SQLArgument> literals = new ArrayList<SQLArgument>(); for ( Object particle : particles ) { if ( particle instanceof SQLExpression ) { if ( particle instanceof SQLArgument ) { literals.add( (SQLArgument) particle ); } else { literals.addAll( ( (SQLExpression) particle ).getArguments() ); } } } return literals; }
private SQLExpression toProtoSQL( Geometry geom, ICRS targetCRS, int srid ) throws FilterEvaluationException { return new SQLArgument( geom, new PostGISGeometryConverter( null, targetCRS, "" + srid, useLegacyPredicates ) ); } }
/** * Ensures that the given {@link SQLExpression} is not an {@link SQLExpression} that is multi-valued. * * @param expr * SQL expression, must not be <code>null</code> * @throws UnmappableException */ protected void assertNotMultiValued( SQLExpression expr ) throws UnmappableException { if ( expr.isMultiValued() ) { String msg = "Cannot apply filter as it refers to a column that stores multiple values in concatenated form.'"; throw new UnmappableException( msg ); } } }
private void inferType( SQLExpression expr1, SQLExpression expr2 ) { PrimitiveType pt1 = expr1.getPrimitiveType(); PrimitiveType pt2 = expr2.getPrimitiveType(); if ( pt1 == null && pt2 != null ) { expr1.cast( expr2 ); } else if ( pt1 != null && pt2 == null ) { expr2.cast( expr1 ); } else if ( pt1 != null && pt2 != null ) { if ( pt1.getBaseType() != pt2.getBaseType() ) { LOG.warn( "Comparison on different types (" + pt1 + "/" + pt2 + "). Relying on db type conversion." ); } } }
protected TypedObjectNode evaluateFunction( Function function, List<SQLExpression> params ) throws FilterEvaluationException { List<TypedObjectNode[]> args = new ArrayList<TypedObjectNode[]>(); for ( SQLExpression sqlExpr : params ) { SQLArgument sqlArg = (SQLArgument) sqlExpr; args.add( new TypedObjectNode[] { sqlArg.getValue() } ); } TypedObjectNode[] outputs = function.evaluate( args ); TypedObjectNode value = null; if ( outputs.length > 0 ) { // TODO should we support multiple values here? value = outputs[0]; } return value; }
@Override protected SQLExpression toProtoSQL( ValueReference expr ) throws UnmappableException, FilterEvaluationException { // TODO PrimitiveType pt = new PrimitiveType( STRING ); PrimitiveParticleConverter converter = new DefaultPrimitiveConverter( pt, expr.getAsQName().getLocalPart().toLowerCase(), false ); return new SQLColumn( null, expr.getAsQName().getLocalPart().toLowerCase(), converter ); }
@Override public void cast( SQLExpression expr ) { ParticleConverter<?> converter = expr.getConverter(); if ( converter instanceof PrimitiveParticleConverter ) { PrimitiveParticleConverter ppc = (PrimitiveParticleConverter) converter; this.pt = ppc.getType(); this.converter = converter; if ( value != null ) { value = new PrimitiveValue( value.toString(), pt ); } } else { LOG.warn( "Type casts for non-primitive values shouldn't occur." ); } }
private void inferType( SQLExpression expr1, SQLExpression expr2, SQLExpression expr3 ) { PrimitiveType pt1 = expr1.getPrimitiveType(); PrimitiveType pt2 = expr2.getPrimitiveType(); PrimitiveType pt3 = expr3.getPrimitiveType(); if ( pt1 != null ) { inferType( expr1, expr2 ); inferType( expr1, expr3 ); } else if ( pt2 != null ) { inferType( expr2, expr1 ); inferType( expr2, expr3 ); } else if ( pt3 != null ) { inferType( expr3, expr1 ); inferType( expr3, expr2 ); } }
@Override public SQLExpression toProtoSQL( List<SQLExpression> args, SQLDialect dialect ) { if ( args.size() != 1 ) { throw new IllegalArgumentException( "Unable to map function '" + NAME + "' to SQL. Expected a single argument." ); } SQLExpression arg = args.get( 0 ); // TODO infer type information on arguments // arg.cast( expr ); SQLOperationBuilder builder = new SQLOperationBuilder( VARCHAR ); builder.add( "area(" ); builder.add( arg ); builder.add( ")" ); return builder.toOperation(); }
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; }
private SQLExpression toProtoSQL( Geometry geom, ICRS targetCRS, int srid ) { // always use is2d = true (else srid handling will not function properly in mssql) return new SQLArgument( geom, new MSSQLGeometryConverter( null, targetCRS, "" + srid, true ) ); } }
private SQLOperation toProtoSql( PropertyIsLike op, String literal ) throws UnmappableException, FilterEvaluationException { String escape = "" + op.getEscapeChar(); String wildCard = "" + op.getWildCard(); String singleChar = "" + op.getSingleChar(); SQLExpression propName = toProtoSQL( op.getExpression() ); IsLikeString specialString = new IsLikeString( literal, wildCard, singleChar, escape ); String sqlEncoded = specialString.toSQL( !op.isMatchCase() ); if ( propName.isMultiValued() ) { // TODO escaping of pipe symbols sqlEncoded = "%|" + sqlEncoded + "|%"; } return getOperationFromBuilder( op, propName, sqlEncoded ); }
@Override public void cast( SQLExpression expr ) { ParticleConverter<?> converter = expr.getConverter(); if ( !( converter instanceof PrimitiveParticleConverter ) || ( (PrimitiveParticleConverter) converter ).getType().getBaseType() != this.pt.getBaseType() ) { throw new UnsupportedOperationException( "Column type casts are not implemented yet." ); } }
@Override public SQLExpression toProtoSQL( List<SQLExpression> args, SQLDialect dialect ) { if ( args.size() != 1 ) { throw new IllegalArgumentException( "Unable to map function '" + NAME + "' to SQL. Expected a single argument." ); } SQLExpression arg = args.get( 0 ); // TODO infer type information on arguments // arg.cast( expr ); SQLOperationBuilder builder = new SQLOperationBuilder( VARCHAR ); builder.add( "lower(" ); builder.add( arg ); builder.add( ")" ); return builder.toOperation(); }
@Override public SQLExpression toProtoSQL( List<SQLExpression> args, SQLDialect dialect ) { if ( args.size() != 1 ) { throw new IllegalArgumentException( "Unable to map function '" + NAME + "' to SQL. Expected a single argument." ); } SQLExpression arg = args.get( 0 ); // TODO infer type information on arguments // arg.cast( expr ); SQLOperationBuilder builder = new SQLOperationBuilder( VARCHAR ); builder.add( "upper(" ); builder.add( arg ); builder.add( ")" ); return builder.toOperation(); }