/** * Get a default data type if a field is null. */ protected static <T> DataType<T> nullSafeDataType(Field<T> field) { return (DataType<T>) (field == null ? SQLDataType.OTHER : field.getDataType()); }
Trunc(Field<T> field, Field<Integer> decimals) { super("trunc", field.getDataType()); this.field = field; this.decimals = decimals; }
Mod(Field<T> arg1, Field<? extends Number> arg2) { super("mod", arg1.getDataType(), arg1, arg2); this.arg1 = arg1; this.arg2 = arg2; }
Nvl2(Field<?> arg1, Field<T> arg2, Field<T> arg3) { super("nvl2", arg2.getDataType(), arg1, arg2, arg3); this.arg1 = arg1; this.arg2 = arg2; this.arg3 = arg3; }
DateAdd(Field<T> date, Field<? extends Number> interval, DatePart datePart) { super("dateadd", date.getDataType()); this.date = date; this.interval = interval; this.datePart = datePart; }
@SuppressWarnings("unchecked") private static final <T> DataType<T> dataType(Map<? extends Field<?>, ? extends Field<T>> map) { if (map.isEmpty()) return (DataType<T>) SQLDataType.OTHER; else return map.entrySet().iterator().next().getValue().getDataType(); }
/** * Get the null field. */ static <T> Field<T> NULL(Field<T> field) { return NULL(field.getDataType()); }
/** * Use the CUBRID-specific <code>INCR()</code> function. * <p> * This function can be used to increment a field value in a * <code>SELECT</code> statement as such: <code><pre> * SELECT article, INCR(read_count) * FROM article_table * WHERE article_id = 130,987</pre></code> */ public static <T> Field<T> incr(Field<T> field) { return field("{incr}({0})", field.getDataType(), field); }
LeadLag(String function, Field<T> field, int offset, Field<T> defaultValue) { super(function, field.getDataType(), field, inline(offset), defaultValue); this.function = function; this.field = field; this.offset = offset; this.defaultValue = defaultValue; }
CaseConditionStepImpl(Condition condition, Field<T> result) { super("case", result.getDataType()); this.conditions = new ArrayList<Condition>(); this.results = new ArrayList<Field<T>>(); when(condition, result); }
LazyVal(T value, Field<T> field) { super(AbstractParam.name(value, null), field.getDataType()); this.value = value; this.field = field; }
@Override public final DataType<?>[] dataTypes() { int size = fields.length; DataType<?>[] result = new DataType[size]; for (int i = 0; i < size; i++) { result[i] = field(i).getDataType(); } return result; }
@SuppressWarnings({ "rawtypes", "unchecked" }) private static <T> DataType<T[]> type(Collection<? extends Field<T>> fields) { if (fields == null || fields.isEmpty()) return (DataType) SQLDataType.OTHER.getArrayDataType(); else return fields.iterator().next().getDataType().getArrayDataType(); }
/** * Type-safety... */ private <T> void addValue0(InsertQuery<R> insert, Field<T> field, Object row) { insert.addValue(field, field.getDataType().convert(row)); }
/** * Get a type-safe condition */ private <T> Condition getCondition(Field<T> field, Object string) { return field.equal(field.getDataType().convert(string)); }
@Override public int getColumnType(int column) throws SQLException { rs.checkNotClosed(); return rs.result.field(column - 1).getDataType().getSQLType(); }
@Override public String getColumnTypeName(int column) throws SQLException { rs.checkNotClosed(); return rs.result.field(column - 1).getDataType().getTypeName(); }
@Override final Fields<Record> fields0() { List<Field<?>> fields = new ArrayList<Field<?>>(); for (Table<?> table : tables) for (Field<?> field : table.fields()) fields.add(DSL.field(DSL.name(field.getName()), field.getDataType())); return new Fields<Record>(fields); }
/** * Get the <code>array_agg()</code> aggregate function. */ @Support({ HSQLDB, POSTGRES }) public static <T> ArrayAggOrderByStep<T[]> arrayAggDistinct(Field<T> field) { return new org.jooq.impl.Function<T[]>(Term.ARRAY_AGG, true, field.getDataType().getArrayDataType(), nullSafe(field)); }
/** * The PostgreSQL <code>array_cat(anyarray, anyelement)</code> function. * <p> * Example: <code><pre> * {1, 2, 3, 4, 5} = array_cat(ARRAY[1, 2], ARRAY[3, 4, 5]) * </pre></code> */ @Support({ POSTGRES }) public static <T> Field<T[]> arrayCat(Field<T[]> array1, Field<T[]> array2) { return field("{array_cat}({0}, {1})", nullSafe(array1).getDataType(), nullSafe(array1), nullSafe(array2)); }