public ColumnLabelImpl(ColumnIdentifier<?> identifier) { label = identifier.getDbmsId() + "." + identifier.getSchemaId() + "." + identifier.getTableId() + "." + identifier.getColumnId(); }
StageBean(JoinType joinType, HasComparableOperators<T, ?> field) { requireNonNull(field); this.identifier = requireNonNull(field.identifier().asTableIdentifier()); this.predicates = new ArrayList<>(); this.joinType = requireNonNull(joinType); this.field = field; }
/** * Returns the full name used in the database for the specified * ColumnIdentifier. This is typically constructed by combining the schema, * table and column name with a separator, but that might be different in * different implementations. * * @param fieldIdentifier to use * @return the full name */ default String fullNameOf(ColumnIdentifier<?> fieldIdentifier) { return fullNameOf(fieldIdentifier.getSchemaId(), fieldIdentifier.getTableId(), fieldIdentifier.getColumnId()); }
/** * Returns a {@link TableIdentifier} that has the same {@code dbmsId}, * {@code schemaId} and {@code tableId} as this * {@link ColumnIdentifier}. * * @return the table identifier */ default TableIdentifier<ENTITY> asTableIdentifier() { return TableIdentifier.of(getDbmsId(), getSchemaId(), getTableId()); }
@Override public String toString() { return StringFieldImpl.class.getSimpleName() + "{" + identifier.getColumnId() + "}"; } }
public StringFieldImpl( final ColumnIdentifier<ENTITY> identifier, final ReferenceGetter<ENTITY, String> getter, final ReferenceSetter<ENTITY, String> setter, final TypeMapper<D, String> typeMapper, final boolean unique ) { this.identifier = requireNonNull(identifier); this.getter = requireNonNull(getter); this.setter = requireNonNull(setter); this.typeMapper = requireNonNull(typeMapper); this.unique = unique; this.tableAlias = identifier.getTableId(); }
public static Optional<? extends Schema> referencedSchemaIfPresent(Project project, ColumnIdentifier<?> identifier) { return referencedSchemaIfPresent(project, identifier.getDbmsId(), identifier.getSchemaId()); }
public static Optional<? extends Dbms> referencedDbmsIfPresent(Project project, ColumnIdentifier<?> identifier) { return referencedDbmsIfPresent(project, identifier.getDbmsId()); }
/** * Returns a {@link ColumnIdentifier} that represents a particular column in * this table. * * @param columnId the database id of the column * @return the column identifier */ default ColumnIdentifier<ENTITY> asColumnIdentifier(String columnId) { return ColumnIdentifier.of( getDbmsId(), getSchemaId(), getTableId(), columnId ); }
public FieldSetImpl(Stream<Field<ENTITY>> fieldStream) { Set<String> ids = fieldStream.map(f -> f.identifier().getColumnId()).collect(Collectors.toSet()); switch (ids.size()) { case 0: includedId = $ -> false; break; case 1: final String id = ids.iterator().next(); includedId = id::equals; break; default: includedId = ids::contains; } }
public ReferenceFieldImpl( final ColumnIdentifier<ENTITY> identifier, final ReferenceGetter<ENTITY, V> getter, final ReferenceSetter<ENTITY, V> setter, final TypeMapper<D, V> typeMapper, final boolean unique ) { this.identifier = requireNonNull(identifier); this.getter = requireNonNull(getter); this.setter = requireNonNull(setter); this.typeMapper = requireNonNull(typeMapper); this.unique = unique; this.tableAlias = identifier.getTableId(); }
/** * Returns the full name used in the database for the specified * ColumnIdentifier. This is typically constructed by combining the schema, * table and column name with a separator, but that might be different in * different implementations. * * @param fieldIdentifier to use * @return the full name */ default String fullNameOf(ColumnIdentifier<?> fieldIdentifier) { return fullNameOf(fieldIdentifier.getSchemaId(), fieldIdentifier.getTableId(), fieldIdentifier.getColumnId()); }
public static Optional<? extends Table> referencedTableIfPresent(Project project, ColumnIdentifier<?> identifier) { return referencedTableIfPresent(project, identifier.getDbmsId(), identifier.getSchemaId(), identifier.getTableId()); }
public static Optional<? extends Column> referencedColumnIfPresent(Project project, ColumnIdentifier<?> identifier) { return referencedColumnIfPresent(project, identifier.getDbmsId(), identifier.getSchemaId(), identifier.getTableId(), identifier.getColumnId()); }
private static void renderPredicate( final StringBuilder sb, final DatabaseNamingConvention naming, final int stageIndex, final int foreignStageIndex, final HasComparableOperators<?, ?> field, final HasComparableOperators<?, ?> foreignField, final String operator ) { sb.append(tableAlias(stageIndex)) .append(".") .append(naming.encloseField(field.identifier().getColumnId())) .append(" ") .append(operator) .append(" ") .append(tableAlias(foreignStageIndex)) .append(".") .append(naming.encloseField(foreignField.identifier().getColumnId())); }
public ComparableFieldImpl( ColumnIdentifier<ENTITY> identifier, ReferenceGetter<ENTITY, V> getter, ReferenceSetter<ENTITY, V> setter, TypeMapper<D, V> typeMapper, boolean unique) { this.identifier = requireNonNull(identifier); this.getter = requireNonNull(getter); this.setter = requireNonNull(setter); this.typeMapper = requireNonNull(typeMapper); this.unique = unique; this.tableAlias = identifier.getTableId(); }
private static <T> String tableIdentifierString(HasComparableOperators<T, ?> foreignField) { if (hasAlias(foreignField)) { return foreignField.tableAlias(); // The alias replaces both schema and table. } final TableIdentifier<T> tableIdentifier = foreignField.identifier().asTableIdentifier(); return tableIdentifier.getDbmsId() + "." + tableIdentifier.getSchemaId() + "." + tableIdentifier.getTableId(); }
@Override public boolean equals(Object o) { if (this == o) return true; if (!(o instanceof ColumnIdentifier)) return false; final ColumnIdentifier<?> that = (ColumnIdentifier<?>) o; return dbms.equals(that.getDbmsId()) && schema.equals(that.getSchemaId()) && table.equals(that.getTableId()) && column.equals(that.getColumnId()); }
@Override public FieldSet<ENTITY> and(Field<ENTITY> field) { String id = field.identifier().getColumnId(); return new FieldSetImpl<>(s -> id.equals(s) || test(s)); } }
public ComparableForeignKeyFieldImpl( final ColumnIdentifier<ENTITY> identifier, final ReferenceGetter<ENTITY, V> getter, final ReferenceSetter<ENTITY, V> setter, final HasComparableOperators<FK_ENTITY, V> referenced, final TypeMapper<D, V> typeMapper, final boolean unique ) { this.identifier = requireNonNull(identifier); this.getter = requireNonNull(getter); this.setter = requireNonNull(setter); this.referenced = requireNonNull(referenced); this.typeMapper = requireNonNull(typeMapper); this.unique = unique; this.tableAlias = identifier.getTableId(); }