private void putBatch(DSLContext ctx, TableReference tableRef, PutBatch batch, boolean allowReinserts) { InsertValuesStep4<Record, byte[], byte[], Long, byte[]> query = ctx.insertInto(table(tableName(tableRef)), field(ROW_NAME, byte[].class), field(COL_NAME, byte[].class), field(TIMESTAMP, Long.class), field(VALUE, byte[].class)); query = batch.addValuesForInsert(query); try { query.execute(); } catch (DataAccessException e) { if (allowReinserts) { Result<? extends Record> records = ctx .select(A_ROW_NAME, A_COL_NAME, A_TIMESTAMP, A_VALUE) .from(atlasTable(tableRef).as(ATLAS_TABLE)) .where(row(A_ROW_NAME, A_COL_NAME, A_TIMESTAMP).in(batch.getRowsForSelect())) .fetch(); if (records.isEmpty()) { throw e; } PutBatch nextBatch = batch.getNextBatch(records); if (nextBatch != null) { putBatch(ctx, tableRef, nextBatch, allowReinserts); return; } } throw new KeyAlreadyExistsException("Conflict on table " + tableRef, e); } }
/** * Get the null field. */ static <T> Field<T> NULL(DataType<T> type) { return field("null", type); }
TableLike<?> values(DSLContext ctx, RowN[] rows, String tableName, String... fieldNames) { switch (sqlDialect.family()) { case H2: List<SelectField<?>> fields = Lists.newArrayListWithCapacity(fieldNames.length); for (int i = 1; i <= fieldNames.length; i++) { fields.add(DSL.field("C" + i).as(fieldNames[i-1])); } RenderContext context = ctx.renderContext(); context.start(TABLE_VALUES) .keyword("values") .formatIndentLockStart(); boolean firstRow = true; for (Row row : rows) { if (!firstRow) { context.sql(',').formatSeparator(); } context.sql(row.toString()); firstRow = false; } context.formatIndentLockEnd() .end(TABLE_VALUES); String valuesClause = context.render(); return ctx.select(fields).from(valuesClause).asTable(tableName); default: return DSL.values(rows).as(tableName, fieldNames); } }
private static final FieldOrRow toFieldOrRow(ParserContext ctx, QueryPart part) { if (part == null) return null; else if (part instanceof Field) return (Field) part; else if (part instanceof Condition) return field((Condition) part); else if (part instanceof Row) return (Row) part; else throw ctx.expected("Field or row"); }
private static final Field<?> toField(ParserContext ctx, QueryPart part) { if (part == null) return null; else if (part instanceof Field) return (Field) part; else if (part instanceof Condition) return field((Condition) part); else throw ctx.expected("Field"); }
/** * Retrieve the Oracle-specific <code>LEVEL</code> pseudo-field (to be used * along with <code>CONNECT BY</code> clauses). */ @Support({ CUBRID }) public static Field<Integer> level() { return field("level", Integer.class); }
/** * Retrieve the Oracle-specific <code>CONNECT_BY_ISCYCLE</code> pseudo-field * (to be used along with <code>CONNECT BY</code> clauses). */ @Support({ CUBRID }) public static Field<Boolean> connectByIsCycle() { return field("connect_by_iscycle", Boolean.class); }
/** * Retrieve the Oracle-specific <code>ROWNUM</code> pseudo-field. */ @Support({ CUBRID }) public static Field<Integer> rownum() { return field("rownum", Integer.class); }
CountTable(Table<?> table, boolean distinct) { super("count", distinct, SQLDataType.INTEGER, DSL.field("{0}", DSL.name(table.getName()))); this.table = table; this.distinct = distinct; }
@Override final Fields<Record1<Integer>> fields0() { return new Fields<Record1<Integer>>(DSL.field(name("generate_series"), Integer.class)); } }
static final Field<?>[] unqualified(Field<?>[] fields) { if (fields == null) return null; Field<?>[] result = new Field[fields.length]; for (int i = 0; i < fields.length; i++) result[i] = DSL.field(fields[i].getUnqualifiedName(), fields[i].getDataType()); return result; }
@Override final Field<String> getFunction0(Configuration configuration) { switch (configuration.family()) { case FIREBIRD: return DSL.field("{trim}({trailing} {from} {0})", SQLDataType.VARCHAR, argument); default: return function("rtrim", SQLDataType.VARCHAR, argument); } } }
@Override final QueryPart getFunction0(Configuration configuration) { switch (configuration.dialect().family()) { default: return DSL.field("{acos}({0})", getDataType(), arg); } } }
/** * The PostgreSQL <code>array(select)</code> function. * <p> * Example: <code><pre> * {1, 2, 3} = array(select 1 union select 2 union select 3) * </pre></code> */ @SuppressWarnings({ "rawtypes", "unchecked" }) @Support({ POSTGRES }) public static <T> Field<T[]> array(Select<? extends Record1<T>> select) { return DSL.field("array({0})", (DataType) select.getSelect().get(0).getDataType().getArrayDataType(), select); }
@Override final QueryPart getFunction0(Configuration configuration) { switch (configuration.dialect().family()) { default: return DSL.field("{lower}({0})", getDataType(), field); } } }
ArrayTableEmulation(Object[] array, Name alias, Name fieldAlias) { super(alias); this.array = array; this.alias = alias; this.fieldAlias = fieldAlias == null ? DSL.name("COLUMN_VALUE") : fieldAlias; this.field = new Fields<Record>(DSL.field(name(alias.last(), this.fieldAlias.last()), DSL.getDataType(array.getClass().getComponentType()))); }
@Override public final AlterTableImpl to(Name newName) { if (renameColumn != null) return to(field(newName)); else if (renameConstraint != null) return to(constraint(newName)); else if (renameIndex != null) { return to(index(newName)); } else throw new IllegalStateException(); }
static final <T> Field<T> qualify(Table<?> table, Field<T> field) { Field<T> result = table.field(field); if (result != null) return result; Name[] part = table.getQualifiedName().parts(); Name[] name = new Name[part.length + 1]; System.arraycopy(part, 0, name, 0, part.length); name[part.length] = field.getUnqualifiedName(); return DSL.field(DSL.name(name), field.getDataType()); }
@Override final Field<BigDecimal> getFunction0(Configuration configuration) { switch (configuration.dialect().family()) { case DERBY: case SQLITE: return DSL.exp(DSL.ln(arg1).mul(arg2)); default: return DSL.field("{power}({0}, {1})", SQLDataType.NUMERIC, getArguments()); } } }