All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • com.kenshoo.pl.entity.internal.fetch.OldEntityFetcher Maven / Gradle / Ivy

    package com.kenshoo.pl.entity.internal.fetch;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Sets;
import com.kenshoo.jooq.*;
import com.kenshoo.pl.data.ImpersonatorTable;
import com.kenshoo.pl.entity.UniqueKey;
import com.kenshoo.pl.entity.*;
import com.kenshoo.pl.entity.CurrentEntityState;
import com.kenshoo.pl.entity.internal.EntityTypeReflectionUtil;
import com.kenshoo.pl.entity.internal.PartialEntityInvocationHandler;
import org.jooq.*;
import org.jooq.lambda.Seq;

import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.*;
import java.util.function.Predicate;
import java.util.stream.Stream;

import static java.util.Collections.emptyList;
import static java.util.Objects.requireNonNull;
import static java.util.function.Function.identity;
import static java.util.stream.Collectors.*;
import static org.apache.commons.lang3.Validate.notEmpty;
import static org.jooq.lambda.Seq.seq;
import static org.jooq.lambda.function.Functions.not;


public class OldEntityFetcher {

    private final DSLContext dslContext;

    public OldEntityFetcher(DSLContext dslContext) {
        this.dslContext = dslContext;
    }


    public > Map, CurrentEntityState> fetchEntitiesByIds(final Collection> ids,
                                                                                               final EntityField... fieldsToFetchArgs) {
        return fetchEntitiesByIds(ids, ImmutableList.copyOf(fieldsToFetchArgs));
    }

    public > Map, CurrentEntityState> fetchEntitiesByIds(final Collection> ids,
                                                                                               final Collection> fieldsToFetch) {
        if (ids.isEmpty()) {
            return Collections.emptyMap();
        }
        final UniqueKey uniqueKey = ids.iterator().next().getUniqueKey();
        final EntityType entityType = uniqueKey.getEntityType();
        final AliasedKey aliasedKey = new AliasedKey<>(uniqueKey);

        final SelectJoinStep query = buildFetchQuery(entityType.getPrimaryTable(), aliasedKey.aliasedFields(), fieldsToFetch);
        try (QueryExtension> queryExtender = queryExtender(query, entityType.getPrimaryTable(), ids)) {
            return fetchEntitiesMap(queryExtender.getQuery(), aliasedKey, fieldsToFetch);
        }
    }

    public List fetch(final EntityType entityType,
                                          final PLCondition plCondition,
                                          final EntityField... fieldsToFetch) {

        final Set> requestedFieldsToFetch = ImmutableSet.copyOf(fieldsToFetch);
        final Set> allFieldsToFetch = Sets.union(requestedFieldsToFetch, plCondition.getFields());

        final SelectJoinStep query = buildFetchQuery(entityType.getPrimaryTable(), emptyList(), allFieldsToFetch);
        final Condition completeJooqCondition = addVirtualPartitionConditions(entityType, plCondition.getJooqCondition());

        return query.where(completeJooqCondition)
                .fetch(record -> mapRecordToEntity(record, requestedFieldsToFetch));
    }

    public List fetch(final EntityType entityType,
                                          final Collection> ids,
                                          final PLCondition plCondition,
                                          final EntityField... fieldsToFetch) {

        if (ids.isEmpty()) {
            return Collections.emptyList();
        }

        final UniqueKey uniqueKey = ids.iterator().next().getUniqueKey();
        final AliasedKey aliasedKey = new AliasedKey<>(uniqueKey);

        final Set> requestedFieldsToFetch = ImmutableSet.copyOf(fieldsToFetch);
        final Set> conditions = Stream.concat(plCondition.getFields().stream(), Arrays.stream(uniqueKey.getFields())).collect(toSet());
        final Set> allFieldsToFetch = Sets.union(requestedFieldsToFetch, conditions);

        final SelectJoinStep query = buildFetchQuery(entityType.getPrimaryTable(), aliasedKey.aliasedFields(), allFieldsToFetch);
        final Condition completeJooqCondition = addVirtualPartitionConditions(entityType, plCondition.getJooqCondition());

        try (QueryExtension> queryExtender = queryExtender(query, entityType.getPrimaryTable(), (Collection)ids)) {
            return queryExtender.getQuery().where(completeJooqCondition)
                    .fetch(record -> mapRecordToEntity(record, requestedFieldsToFetch));
        }
    }


    public > Map, CurrentEntityState> fetchEntitiesByForeignKeys(E entityType, UniqueKey foreignUniqueKey, Collection> keys, Collection> fieldsToFetch) {
        try (final TempTableResource foreignKeysTable = createForeignKeysTable(entityType.getPrimaryTable(), foreignUniqueKey, keys)) {
            final AliasedKey aliasedKey = new AliasedKey<>(foreignUniqueKey, foreignKeysTable);
            final SelectJoinStep query = buildFetchQuery(foreignKeysTable.getTable(), aliasedKey.aliasedFields(), fieldsToFetch);

            return fetchEntitiesMap(query, aliasedKey, fieldsToFetch);
        }
    }

    public , PE extends PartialEntity, ID extends Identifier> Map fetchPartialEntities(E entityType, Collection keys, final Class entityIface) {
        if (keys.isEmpty()) {
            return Collections.emptyMap();
        }
        UniqueKey uniqueKey = keys.iterator().next().getUniqueKey();
        final Map> entityMethodsMap = EntityTypeReflectionUtil.getMethodsMap(entityType, entityIface);
        Map, CurrentEntityState> entityMap = fetchEntitiesByIds(keys, entityMethodsMap.values());
        ClassLoader classLoader = entityIface.getClassLoader();
        Class[] interfaces = {entityIface};
        //noinspection unchecked
        return keys.stream().filter(entityMap::containsKey)
                .collect(toMap(identity(), key -> (PE) Proxy.newProxyInstance(classLoader, interfaces, new PartialEntityInvocationHandler<>(entityMethodsMap, entityMap.get(key)))));
    }

    public , PE extends PartialEntity> List fetchByCondition(E entityType, Condition condition, final Class entityIface) {
        final Map> entityMethodsMap = EntityTypeReflectionUtil.getMethodsMap(entityType, entityIface);
        final Collection> fieldsToFetch = entityMethodsMap.values();
        SelectJoinStep query = buildFetchQuery(entityType.getPrimaryTable(), Collections.>emptyList(), fieldsToFetch);
        for (FieldAndValue fieldAndValue : entityType.getPrimaryTable().getVirtualPartition()) {
            //noinspection unchecked
            condition = condition.and(fieldAndValue.getField().eq(fieldAndValue.getValue()));
        }
        List entities = query.where(condition).fetch(record -> {
            CurrentEntityMutableState currentState = new CurrentEntityMutableState();
            Iterator valuesIterator = record.intoList().iterator();
            for (EntityField field : fieldsToFetch) {
                fieldFromRecordToEntity(currentState, field, valuesIterator);
            }
            return currentState;
        });
        //noinspection unchecked
        ClassLoader classLoader = entityIface.getClassLoader();
        Class[] interfaces = {entityIface};
        //noinspection unchecked
        return entities.stream()
                .map(currentState -> (PE) Proxy.newProxyInstance(classLoader, interfaces, new PartialEntityInvocationHandler<>(entityMethodsMap, currentState)))
                .collect(toList());
    }

    /*
     This method generates a query that joins the starting table with one or more foreign keys, with the tables
     necessary to get to all fieldsToFetch. This is done by traversing the tree that starts at the starting table and
     follows all possible foreign keys, in the BFS manner. As soon as a table containing one of the fieldsToFetch is found,
     the necessary joins are made and the participating tables are marked as already joined. The target table is removed
     from the set of tables to fetch. The traversal continues until there are tables in this set.
     */
    private SelectJoinStep buildFetchQuery(DataTable startingTable, Collection> aliasedKeyFields, Collection> fieldsToFetch) {
        // The set of tables to reach with joins. This set is mutable, the tables are removed from it as they are reached
        Set targetPrimaryTables = fieldsToFetch.stream()
                .map(field -> field.getEntityType().getPrimaryTable())
                .filter(tb -> !tb.equals(startingTable))
                .collect(toSet());

        final Set targetOneToOneRelations = fieldsToFetch.stream()
                .filter(not(isOfPrimaryTable()))
                .map(field -> OneToOneTableRelation.builder()
                        .secondary(field.getDbAdapter().getTable())
                        .primary(field.getEntityType().getPrimaryTable())
                        .build())
                .collect(toSet());

        List> selectFields = dbFieldsOf(fieldsToFetch).concat(seq(aliasedKeyFields)).toList();

        final SelectJoinStep query = dslContext.select(selectFields).from(startingTable);
        final Set joinedTables = Sets.newHashSet(startingTable);
        final TreeEdge startingEdge = new TreeEdge(null, startingTable);

        BFS.visit(startingEdge, this::edgesComingOutOf)
                .limitUntil(__ -> targetPrimaryTables.isEmpty())
                .forEach(edge -> {
                    final DataTable table = edge.target.table;

                    if (edge != startingEdge && targetPrimaryTables.contains(table)) {
                        targetPrimaryTables.remove(table);
                        QueryBuilder.joinTables(query, joinedTables, edge);
                    }
                });

        if (!targetPrimaryTables.isEmpty()) {
            throw new IllegalStateException("Tables " + targetPrimaryTables + " could not be reached via joins");
        }

        QueryBuilder.joinSecondaryTables(query, joinedTables, targetOneToOneRelations);

        return query;
    }

    private , Q extends SelectJoinStep> QueryExtension queryExtender(Q query, DataTable primaryTable, Collection> ids) {
        final UniqueKey uniqueKey = ids.iterator().next().getUniqueKey();
        List> conditions = new ArrayList<>();
        for (EntityField field : uniqueKey.getFields()) {
            addToConditions(field, ids, conditions);
        }
        primaryTable.getVirtualPartition().forEach(fieldAndValue -> {
            Object[] values = new Object[ids.size()];
            Arrays.fill(values, fieldAndValue.getValue());
            //noinspection unchecked
            conditions.add(new FieldAndValues<>((Field) fieldAndValue.getField(), Arrays.asList(values)));
        });
        return SelectQueryExtender.of(dslContext, query, conditions);
    }

    private , T> void addToConditions(EntityField field, Collection> identifiers, List> conditions) {
        EntityFieldDbAdapter dbAdapter = field.getDbAdapter();
        List fieldValues = new ArrayList<>(identifiers.size());
        for (Identifier identifier : identifiers) {
            dbAdapter.getDbValues(identifier.get(field)).sequential().forEach(fieldValues::add);
        }
        Optional> tableField = dbAdapter.getTableFields().findFirst();
        //noinspection unchecked
        conditions.add(new FieldAndValues<>((TableField) tableField.get(), fieldValues));
    }

    private Predicate> isOfPrimaryTable() {
        return field -> field.getDbAdapter().getTable().equals(field.getEntityType().getPrimaryTable());
    }

    private Seq edgesComingOutOf(TreeEdge edge) {
        return seq(edge.target.table.getReferences()).map(new ToEdgesOf(edge.target));
    }

    private > Map, CurrentEntityState> fetchEntitiesMap(ResultQuery query, AliasedKey aliasedKey, Collection> fields) {
        return query.fetchMap(record -> RecordReader.createKey(record, aliasedKey), record -> RecordReader.createEntity(record, fields));
    }

    private > TempTableResource createForeignKeysTable(final DataTable primaryTable, final UniqueKey foreignUniqueKey, final Collection> keys) {
        ImpersonatorTable impersonatorTable = new ImpersonatorTable(primaryTable);
        foreignUniqueKey.getTableFields().forEach(impersonatorTable::createField);

        return TempTableHelper.tempInMemoryTable(dslContext, impersonatorTable, batchBindStep -> {
                    for (Identifier key : keys) {
                        EntityField[] keyFields = foreignUniqueKey.getFields();
                        List values = new ArrayList<>();
                        for (EntityField field : keyFields) {
                            addToValues(key, field, values);
                        }
                        batchBindStep.bind(values.toArray());
                    }
                }
        );
    }

    private  void fieldFromRecordToEntity(CurrentEntityMutableState currentState, EntityField field, Iterator valuesIterator) {
         currentState.set(field, field.getDbAdapter().getFromRecord(valuesIterator));
    }

    private , T> void addToValues(Identifier key, EntityField field, List values) {
        field.getDbAdapter().getDbValues(key.get(field)).forEach(values::add);
    }

    private Seq> dbFieldsOf(Collection> fieldsToFetch) {
        return seq(fieldsToFetch).flatMap(field -> field.getDbAdapter().getTableFields());
    }

    private Condition addVirtualPartitionConditions(final EntityType entityType, final Condition inputJooqCondition) {
        return entityType.getPrimaryTable().getVirtualPartition().stream()
                         .map(this::asTypedFieldAndValue)
                         .map(fieldAndValue -> fieldAndValue.getField().eq(fieldAndValue.getValue()))
                         .reduce(inputJooqCondition, Condition::and);
    }

    private CurrentEntityState mapRecordToEntity(final Record record, final Collection> fieldsToFetch) {
        final CurrentEntityMutableState currentState = new CurrentEntityMutableState();
        final Iterator valuesIterator = record.intoList().iterator();
        fieldsToFetch.forEach( field -> fieldFromRecordToEntity(currentState, field, valuesIterator));
        return currentState;
    }

    @SuppressWarnings("unchecked")
    private FieldAndValue asTypedFieldAndValue(final FieldAndValue fv) {
        return (FieldAndValue)fv;
    }
}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy