<p>Convert from EFilterOperator to SQL one.</p>
@param pFilterOperator EFilterOperator
@return SQL operator
@throws Exception if not found
190127
public final String toSqlOperator(
    final EFilterOperator pFilterOperator) throws Exception {
    if (EFilterOperator.LESS_THAN.equals(pFilterOperator)) {
      return "<";
    }
    if (EFilterOperator.LESS_THAN_EQUAL.equals(pFilterOperator)) {
      return "<=";
    }
    if (EFilterOperator.GREATER_THAN.equals(pFilterOperator)) {
      return ">";
    }
    if (EFilterOperator.GREATER_THAN_EQUAL.equals(pFilterOperator)) {
      return ">=";
    }
    throw new Exception(
      "Algorithm error! Cant match SQL operator to EFilterOperator: "
        + pFilterOperator);
  }
1321730
public SqlResult sql(String sqlCommand, String errorMessage) throws DDFException {
    try {
      // sqlCommand = sqlCommand.replace("@this", this.getTableName());
      // TODO: what is format?
      // return this.getManager().sql(String.format(sqlCommand, this.getTableName()));
      sqlCommand = sqlCommand.replace("@this", "{1}");
      sqlCommand = String.format(sqlCommand, "{1}");
      SQLDataSourceDescriptor sqlDS = new SQLDataSourceDescriptor(sqlCommand,
              null, null,null, this.getUUID().toString());
      return this.getManager().sql(sqlCommand, null, sqlDS);
    } catch (Exception e) {
      throw new DDFException(String.format(errorMessage, this.getTableName()), e);
    }
  }
944296
public <E extends Exception> boolean noneMatch(Try.LongPredicate<E> filter) throws E {
        return noneMatch(0, size(), filter);
    }
1218248
public static Response<SearchResult> executeSearchOperation(final ConnectionFactory connectionFactory,
                                                                final String baseDn,
                                                                final SearchFilter filter) throws LdapException {
        return executeSearchOperation(connectionFactory, baseDn, filter, ReturnAttributes.ALL_USER.value(), ReturnAttributes.ALL_USER.value());
    }
536451
public <E extends Exception> boolean noneMatch(Try.FloatPredicate<E> filter) throws E {
        return noneMatch(0, size(), filter);
    }
25818
public static filterglobal_filterpolicy_binding[] get_filtered(nitro_service service, String filter) throws Exception{
		filterglobal_filterpolicy_binding obj = new filterglobal_filterpolicy_binding();
		options option = new options();
		option.set_filter(filter);
		filterglobal_filterpolicy_binding[] response = (filterglobal_filterpolicy_binding[]) obj.getfiltered(service, option);
		return response;
	}
1197856
public <E extends Exception> boolean allMatch(Try.LongPredicate<E> filter) throws E {
        return allMatch(0, size(), filter);
    }
920430
public static final FilterOperation mapFilterAbbreviationToOperation(String abbrev) {
        for(int i = 0; i < FILTER_OPERATIONS.length; i++) {
            FilterOperation fOp = FILTER_OPERATIONS[i];
            if(fOp.getAbbreviation().equals(abbrev))
                return fOp;
        }
        return null;
    }
20280
public boolean first() throws SQLException {
        try {
            if (dsConfig.get().beginTranForResultSetScrollingAPIs)
                getConnectionWrapper().beginTransactionIfNecessary();

            return rsetImpl.first();
        } catch (SQLException ex) {
            FFDCFilter.processException(ex, "com.ibm.ws.rsadapter.jdbc.WSJdbcResultSet.first", "411", this);
            throw WSJdbcUtil.mapException(this, ex);
        } catch (NullPointerException nullX) {
            // No FFDC code needed; we might be closed.
            throw runtimeXIfNotClosed(nullX);
        }
    }
1062390
private Filter createValueMatchFilter(
      FilterAdapterContext context, SingleColumnValueFilter filter) throws IOException {
    ValueFilter valueFilter = new ValueFilter(filter.getOperator(), filter.getComparator());
    return delegateAdapter.toFilter(context, valueFilter);
  }
1337450
public static SQLException toSQLException(Throwable ex) {
        if (ex == null)
            return null; 

        if (ex instanceof SQLException)
            return (SQLException) ex;

        if (ex instanceof ResourceException)
            return toSQLException((ResourceException) ex);

        // Link the original exception to the new SQLException. 

        SQLException sqlX = new SQLException(ex.getClass().getName() + ": " + ex.getMessage());
        sqlX.initCause(ex);

        return sqlX;
    }
214466
@SuppressWarnings("unchecked")
	public <S extends IPAddressPartConfiguredString<T, P>> SQLStringMatcher<T, P, S> getNetworkStringMatcher(boolean isEntireAddress, IPAddressSQLTranslator translator) {
		return new SQLStringMatcher<T, P, S>((S) this, isEntireAddress, translator);
	}
598603
public function getSql()
    {
        if ($this->isEmpty()) {
            throw new Exception("Invalid segment, please specify a valid segment.");
        }
        $sql = '';
        $subExpression = false;
        foreach ($this->tree as $expression) {
            $operator = $expression[self::INDEX_BOOL_OPERATOR];
            $operand = $expression[self::INDEX_OPERAND];

            if ($operator == self::BOOL_OPERATOR_OR
                && !$subExpression
            ) {
                $sql .= ' (';
                $subExpression = true;
            } else {
                $sql .= ' ';
            }

            $sql .= $operand;

            if ($operator == self::BOOL_OPERATOR_AND
                && $subExpression
            ) {
                $sql .= ')';
                $subExpression = false;
            }

            $sql .= " $operator";
        }
        if ($subExpression) {
            $sql .= ')';
        }
        return array(
            'where' => $sql,
            'bind'  => $this->valuesBind,
            'join'  => implode(' ', $this->joins)
        );
    }
518595
protected final int doSelect(Connection c) throws SQLException {
		Statement stmt = null;
		ResultSet rs = null;
		try {
			stmt = c.createStatement();
			rs = stmt.executeQuery("select * from foo");
			int count = 0;
			while (rs.next()) {
				count++;
			}
			return count;
		} finally {
			if (rs != null) {
				rs.close();
			}
			if (stmt != null) {
				stmt.close();
			}
		}
	}
554611
final public Selector ComparisonPredicate() throws ParseException {
                                   Selector left, right; int op;
    left = Expression();
    op = ComparisonOperator();
    right = Expression();
    {if (true) return new OperatorImpl(op, left, right);}
    throw new Error("Missing return statement in function");
  }
232005
public SQLException exceptionWithQuery(SQLException sqlEx, PrepareResult prepareResult) {
    if (options.dumpQueriesOnException || sqlEx.getErrorCode() == 1064) {
      String querySql = prepareResult.getSql();
      String message = sqlEx.getMessage();
      if (options.maxQuerySizeToLog != 0 && querySql.length() > options.maxQuerySizeToLog - 3) {
        message += "\nQuery is: " + querySql.substring(0, options.maxQuerySizeToLog - 3) + "...";
      } else {
        message += "\nQuery is: " + querySql;
      }
      message += "\njava thread: " + Thread.currentThread().getName();
      return new SQLException(message, sqlEx.getSQLState(), sqlEx.getErrorCode(), sqlEx.getCause());
    }
    return sqlEx;
  }
1354791
public <E extends Exception> boolean noneMatch(Try.BytePredicate<E> filter) throws E {
        return noneMatch(0, size(), filter);
    }