private /* non-final */ Field<?>[] pk() { UniqueKey<?> key = table.getPrimaryKey(); return key == null ? null : key.getFieldsArray(); }
@Override public final Result<O> fetchParents(Collection<? extends R> records) { if (records == null || records.size() == 0) { return new ResultImpl<O>(new DefaultConfiguration(), key.getFields()); } else { return fetch(records, key.getTable(), key.getFieldsArray(), getFieldsArray()); } }
private List<Constraint> primaryKeys(Table<?> table) { List<Constraint> result = new ArrayList<Constraint>(); if (flags.contains(PRIMARY_KEY)) for (UniqueKey<?> key : table.getKeys()) if (key.isPrimary()) result.add(constraint(key.getName()).primaryKey(key.getFieldsArray())); return result; }
private String findForeignKeyReference(ForeignKey<?, ?> fk) { UniqueKey<?> pk = fk.getKey(); if (pk != null) { Field<?>[] pks = pk.getFieldsArray(); if (pks.length == 1) { return pk.getTable().getName(); } } return null; }
@SuppressWarnings("unchecked") public static <P extends VertxPojo, R extends UpdatableRecord<R>,T,F> F insertReturningPrimaryAsync(P object, DAO<R,P,T> dao,BiFunction<Query,Function<Long,T>,F> function){ Arguments.require(INSERT_RETURNING_SUPPORT.contains(dao.configuration().dialect()), "Only MySQL supported"); UniqueKey<?> key = dao.getTable().getPrimaryKey(); TableField<? extends Record, ?> tableField = key.getFieldsArray()[0]; Function<Long,T> keyConverter = lastId -> { T checkedResult; if(tableField.getType().equals(Integer.class)){ checkedResult = (T) Integer.valueOf(lastId.intValue()); }else{ checkedResult = (T) lastId; } return checkedResult; }; DSLContext dslContext = DSL.using(dao.configuration()); return function.apply(dslContext.insertInto(dao.getTable()).set(dslContext.newRecord(dao.getTable(), object)).returning(key.getFields()), keyConverter); } }
@Override protected void loadUniqueKeys(DefaultRelations relations) throws SQLException { for (Schema schema : getSchemasFromMeta()) { SchemaDefinition s = getSchema(schema.getName()); if (s != null) { for (Table<?> table : schema.getTables()) { TableDefinition t = getTable(s, table.getName()); if (t != null) { UniqueKey<?> key = table.getPrimaryKey(); if (key != null) { for (Field<?> field : key.getFields()) { ColumnDefinition c = t.getColumn(field.getName()); relations.addPrimaryKey("PK_" + key.getTable().getName(), c); } } } } } } }
@Override public String toString() { StringBuilder sb = new StringBuilder(); sb.append("FOREIGN KEY ("); String s1 = ""; for (Field<?> field : getFields()) { sb.append(s1); sb.append(field); s1 = ", "; } sb.append(") REFERENCES "); sb.append(key.getTable()); sb.append("("); String s2 = ""; for (Field<?> field : getFields()) { sb.append(s2); sb.append(field); s2 = ", "; } sb.append(")"); return sb.toString(); } }
@Override public Constraint constraint() { return DSL.constraint(getName()) .foreignKey(getFieldsArray()) .references(key.getTable(), key.getFieldsArray()); } }
private List<Constraint> uniqueKeys(Table<?> table) { List<Constraint> result = new ArrayList<Constraint>(); if (flags.contains(UNIQUE)) for (UniqueKey<?> key : table.getKeys()) if (!key.isPrimary()) result.add(constraint(key.getName()).unique(key.getFieldsArray())); return result; }
/** * Determines if a table's primary key is referenced at all by other tables. * * @param table * @param others * @return */ public static boolean isReferencedBy(Table<?> table, List<Table<?>> others) { for (Table<?> other : others) { for (ForeignKey<?, ?> key : other.getReferences()) { if (key.getKey().getTable().equals(table)) { return true; } } } return false; }
@Override public final void onConflictOnConstraint(Constraint constraint) { this.onConstraint = constraint; if (onConstraintUniqueKey == null) { for (UniqueKey<R> key : table.getKeys()) { if (constraint.getName().equals(key.getName())) { onConstraintUniqueKey = key; break; } } } }
@SuppressWarnings("unchecked") private Field<ID> pk() { UniqueKey<?> uk = table.getPrimaryKey(); Field<?>[] fs = uk.getFieldsArray(); return (Field<ID>) fs[0]; }
@Override public R operate(R copy) throws RuntimeException { // Copy all fields. This marks them all as isChanged, which is important List<TableField<R, ?>> key = getPrimaryKey().getFields(); for (Field<?> field : fields.fields.fields) { // Don't copy key values if (!key.contains(field)) { setValue(copy, field); } } return copy; }
@Override public final Result<O> fetchParents(Collection<? extends R> records) { if (records == null || records.size() == 0) { return new ResultImpl<O>(new DefaultConfiguration(), key.getFields()); } else { return fetch(records, key.getTable(), key.getFieldsArray(), getFieldsArray()); } }
private List<Constraint> foreignKeys(Table<?> table) { List<Constraint> result = new ArrayList<Constraint>(); if (flags.contains(FOREIGN_KEY)) for (ForeignKey<?, ?> key : table.getReferences()) result.add(constraint(key.getName()).foreignKey(key.getFieldsArray()).references(key.getKey().getTable(), key.getKey().getFieldsArray())); return result; }
/** * {@inheritDoc} */ @SuppressWarnings("unchecked") @Override public final <O extends Record> List<ForeignKey<R, O>> getReferencesTo(Table<O> other) { List<ForeignKey<R, O>> result = new ArrayList<ForeignKey<R, O>>(); for (ForeignKey<R, ?> reference : getReferences()) { if (other.equals(reference.getKey().getTable())) { result.add((ForeignKey<R, O>) reference); } // TODO: Refactor the following two blocks and make things more OO // [#1460] In case the other table was aliased using else if (other instanceof TableImpl) { Table<O> aliased = ((TableImpl<O>) other).getAliasedTable(); if (aliased != null && aliased.equals(reference.getKey().getTable())) { result.add((ForeignKey<R, O>) reference); } } // [#1460] In case the other table was aliased using else if (other instanceof TableAlias) { Table<O> aliased = ((TableAlias<O>) other).getAliasedTable(); if (aliased != null && aliased.equals(reference.getKey().getTable())) { result.add((ForeignKey<R, O>) reference); } } } return Collections.unmodifiableList(result); }