Esempio n. 1
0
  private final QueryPartInternal delegate(Configuration configuration) {
    // These casts are safe for RowImpl
    RowN r = (RowN) row;
    RowN min = (RowN) minValue;
    RowN max = (RowN) maxValue;

    // These dialects don't support the SYMMETRIC keyword at all
    if (symmetric
        && asList(ASE, CUBRID, DB2, DERBY, FIREBIRD, H2, MYSQL, ORACLE, SQLITE, SQLSERVER, SYBASE)
            .contains(configuration.dialect())) {
      if (not) {
        return (QueryPartInternal) r.notBetween(min, max).and(r.notBetween(max, min));
      } else {
        return (QueryPartInternal) r.between(min, max).or(r.between(max, min));
      }
    }

    // These dialects either don't support row value expressions, or they
    // Can't handle row value expressions with the BETWEEN predicate
    else if (row.size() > 1
        && asList(CUBRID, DERBY, FIREBIRD, MYSQL, ORACLE, SQLITE, SQLSERVER, SYBASE)
            .contains(configuration.dialect())) {
      Condition result = r.ge(min).and(r.le(max));

      if (not) {
        result = result.not();
      }

      return (QueryPartInternal) result;
    } else {
      return new Native();
    }
  }
Esempio n. 2
0
  private final QueryPartInternal delegate(Configuration ctx) {
    if (query != null) {
      return (QueryPartInternal) query;
    } else {
      switch (ctx.dialect()) {

          // [#869] Postgres supports this syntax natively
        case POSTGRES:
          {
            return (QueryPartInternal) array;
          }

          // [#869] H2 and HSQLDB can simulate this syntax by unnesting
          // the array in a subselect
        case H2:
        case HSQLDB:

          // [#1048] All other dialects simulate unnesting of arrays using
          // UNION ALL-connected subselects
        default:
          {
            return (QueryPartInternal) create(ctx).select().from(table(array));
          }
      }
    }
  }
Esempio n. 3
0
  @Override
  final Field<BigDecimal> getFunction0(Configuration configuration) {
    switch (configuration.dialect().family()) {
      case ASE:
      case CUBRID:
      case HSQLDB:
      case INGRES:
      case MARIADB:
      case MYSQL:
      case POSTGRES:
      case SQLSERVER:
      case SYBASE:
        return DSL.exp(argument.mul(two())).sub(one()).div(DSL.exp(argument.mul(two())).add(one()));

      default:
        return function("tanh", SQLDataType.NUMERIC, argument);
    }
  }
Esempio n. 4
0
  @SuppressWarnings("unchecked")
  @Override
  final Field<T> getFunction0(Configuration configuration) {

    // In any dialect, a single argument is always the greatest
    if (getArguments().length == 1) {
      return (Field<T>) getArguments()[0];
    }

    switch (configuration.dialect()) {
        // This implementation has O(2^n) complexity. Better implementations
        // are very welcome
        // [#1049] TODO Fix this!

      case ASE:
      case DERBY:
      case SQLSERVER:
      case SYBASE:
        {
          Field<T> first = (Field<T>) getArguments()[0];
          Field<T> other = (Field<T>) getArguments()[1];

          if (getArguments().length > 2) {
            Field<?>[] remaining = new Field[getArguments().length - 2];
            System.arraycopy(getArguments(), 2, remaining, 0, remaining.length);

            return DSL.decode()
                .when(first.greaterThan(other), DSL.greatest(first, remaining))
                .otherwise(DSL.greatest(other, remaining));
          } else {
            return DSL.decode().when(first.greaterThan(other), first).otherwise(other);
          }
        }

      case FIREBIRD:
        return function("maxvalue", getDataType(), getArguments());

      case SQLITE:
        return function("max", getDataType(), getArguments());

      default:
        return function("greatest", getDataType(), getArguments());
    }
  }
Esempio n. 5
0
  private Table<?> pivot(Configuration configuration) {
    switch (configuration.dialect()) {

        /* [pro] xx
        xx xxxxxx xxx xxxxxx xxxxxxx xxx xxx xxxxx xxxxxx
        xxxx xxxxxxx
        xxxx xxxxxxxxxx
        xxxx xxxxxxxxxx x
            xxxxxx xxx xxxxxxxxxxxxxxxxxxx
        x

        xx [/pro] */
        // Some other dialects can simulate it. This implementation is
        // EXPERIMENTAL and not officially supported
      default:
        {
          return new DefaultPivotTable();
        }
    }
  }
Esempio n. 6
0
  @Override
  final Field<String> getFunction0(Configuration configuration) {
    Field<?>[] args = getArguments();

    // [#861] Most dialects don't ship with a two-argument replace function:
    switch (configuration.dialect().family()) {
      case ASE:
        {
          if (args.length == 2) {
            return function("str_replace", VARCHAR, args[0], args[1], val(null));
          } else {
            return function("str_replace", VARCHAR, args);
          }
        }

      case DB2:
      case FIREBIRD:
      case HSQLDB:
      case INGRES:
      case MARIADB:
      case MYSQL:
      case POSTGRES:
      case SQLITE:
      case SQLSERVER:
      case SYBASE:
        {
          if (args.length == 2) {
            return function("replace", VARCHAR, args[0], args[1], val(""));
          } else {
            return function("replace", VARCHAR, args);
          }
        }

      default:
        {
          return function("replace", VARCHAR, args);
        }
    }
  }
Esempio n. 7
0
 @Override
 public SQLDialect dialect() {
   return delegate.dialect();
 }