@Override public void add(String columnName, Value value) { requireNonNull(columnName, "columnName is required"); requireNonNull(value, "value is required"); this.add(Column.of(columnName, value)); }
static DefaultColumnCondition between(Column column) { Objects.requireNonNull(column, "column is required"); checkBetweenClause(column.get()); return new DefaultColumnCondition(column, BETWEEN); }
@Override public void add(Column column) { Objects.requireNonNull(column, "Column is required"); this.columns.put(column.getName(), column); }
@Override public <T> void convert(T instance, List<Column> columns, Optional<Column> column, FieldRepresentation field, AbstractColumnEntityConverter converter) { Value value = column.get().getValue(); Optional<Class<? extends AttributeConverter>> optionalConverter = field.getConverter(); if (optionalConverter.isPresent()) { AttributeConverter attributeConverter = converter.getConverters().get(optionalConverter.get()); Object attributeConverted = attributeConverter.convertToEntityAttribute(value.get()); converter.getReflections().setValue(instance, field.getNativeField(), field.getValue(Value.of(attributeConverted))); } else { converter.getReflections().setValue(instance, field.getNativeField(), field.getValue(value)); } } }
/** * Creates a column instance * * @param name column's name * @param value column's value * @return a column's instance * @throws NullPointerException when either name or value are null */ public static Column of(String name, Object value) { return Column.of(name, Value.of(value)); }
static DefaultColumnCondition in(Column column) { Objects.requireNonNull(column, "column is required"); checkInClause(column.get()); return new DefaultColumnCondition(column, IN); }
protected <T> Consumer<String> feedObject(T instance, List<Column> columns, Map<String, FieldRepresentation> fieldsGroupByName) { return (String k) -> { Optional<Column> column = columns.stream().filter(c -> c.getName().equals(k)).findFirst(); FieldRepresentation field = fieldsGroupByName.get(k); ColumnFieldConverter fieldConverter = converterFactory.get(field); fieldConverter.convert(instance, columns, column, field, this); }; }
@Override public void add(String columnName, Object value) { requireNonNull(columnName, "columnName is required"); requireNonNull(value, "value is required"); this.add(Column.of(columnName, value)); }
private Object convert(Object value) { if (value instanceof Column) { Column column = Column.class.cast(value); return Collections.singletonMap(column.getName(), convert(column.get())); } else if (value instanceof Iterable) { List<Object> list = new ArrayList<>(); Iterable.class.cast(value).forEach(e -> list.add(convert(e))); return list; } return value; }
private <T> Consumer<Column> convertColumn(T instance, FieldRepresentation field, AbstractColumnEntityConverter converter) { return column -> { GenericFieldRepresentation genericField = GenericFieldRepresentation.class.cast(field); Collection collection = genericField.getCollectionInstance(); List<List<Column>> embeddable = (List<List<Column>>) column.get(); for (List<Column> columnList : embeddable) { Object element = converter.toEntity(genericField.getElementType(), columnList); collection.add(element); } converter.getReflections().setValue(instance, field.getNativeField(), collection); }; } }
/** * Converts a Map to columns where: the key gonna be a column's name the value a column's value and null values * elements will be ignored. * * @param values map to be converted * @return a list of columns * @throws NullPointerException when values is null */ public static List<Column> of(Map<String, ?> values) { Objects.requireNonNull(values, "values is required"); return values.entrySet().stream() .filter(IS_VALUE_NULL) .map(e -> Column.of(e.getKey(), getValue(e.getValue()))) .collect(toList()); }
@Override public <T> void convert(T instance, List<Column> columns, Optional<Column> column, FieldRepresentation field, AbstractColumnEntityConverter converter) { if (column.isPresent()) { Column subColumn = column.get(); Object value = subColumn.get(); if (Map.class.isInstance(value)) { Map map = Map.class.cast(value); List<Column> embeddedColumns = new ArrayList<>(); for (Map.Entry entry : (Set<Map.Entry>) map.entrySet()) { embeddedColumns.add(Column.of(entry.getKey().toString(), entry.getValue())); } converter.getReflections().setValue(instance, field.getNativeField(), converter.toEntity(field.getNativeField().getType(), embeddedColumns)); } else { converter.getReflections().setValue(instance, field.getNativeField(), converter.toEntity(field.getNativeField().getType(), subColumn.get(new TypeReference<List<Column>>() { }))); } } else { converter.getReflections().setValue(instance, field.getNativeField(), converter.toEntity(field.getNativeField().getType(), columns)); } } }
protected <T> void betweenImpl(T valueA, T valueB) { requireNonNull(valueA, "valueA is required"); requireNonNull(valueB, "valueB is required"); ColumnCondition newCondition = ColumnCondition.between(Column.of(name, asList(valueA, valueB))); appendCondition(newCondition); }
static DefaultColumnCondition and(ColumnCondition... conditions) { requireNonNull(conditions, "condition is required"); Column column = Column.of(AND.getNameField(), asList(conditions)); return DefaultColumnCondition.of(column, AND); }
static DefaultColumnCondition or(ColumnCondition... conditions) { requireNonNull(conditions, "condition is required"); Column column = Column.of(OR.getNameField(), asList(conditions)); return DefaultColumnCondition.of(column, OR); }
protected <T> void inImpl(Iterable<T> values) { requireNonNull(values, "values is required"); List<Object> convertedValues = StreamSupport.stream(values.spliterator(), false) .map(this::getValue).collect(toList()); ColumnCondition newCondition = ColumnCondition .in(Column.of(representation.getColumnField(name), convertedValues)); appendCondition(newCondition); }