@Before
public void before() {

    ObjectContext sharedContext = TestWithCayenneMapping.runtime.newContext();
    cayenneService = mock(ICayennePersister.class);
    when(cayenneService.sharedContext()).thenReturn(sharedContext);
    when(cayenneService.newContext()).thenReturn(TestWithCayenneMapping.runtime.newContext());

    IAttributeEncoderFactory aef = new AttributeEncoderFactory(new ValueEncodersProvider(Collections.emptyMap()).get());
    IStringConverterFactory stringConverterFactory = mock(IStringConverterFactory.class);
    IRelationshipMapper relationshipMapper = new SenchaRelationshipMapper();

    encoderService = new SenchaEncoderService(
            aef,
            stringConverterFactory,
            relationshipMapper,
            Collections.emptyMap());
}
 

protected <T extends DataObject> void doExecute(DeleteContext<T> context) {

        ObjectContext cayenneContext = CayenneDeleteStartStage.cayenneContext(context);

        // dirty ... we have no concept of DeleteResponse, and we need to
        // pass context to the ObjectMapper, so creating a throwaway response
        // and EntityUpdate .. TODO: somehow need to adapt ObjectMapper to
        // delete responses

        // delete by id
        if (context.isById()) {
            AgEntity<T> agEntity = metadataService.getAgEntity(context.getType());
            deleteById(context, cayenneContext, agEntity);
        }
        // delete by parent
        else if (context.getParent() != null) {
            AgEntity<?> parentAgEntity = metadataService.getAgEntity(context.getParent().getType());
            deleteByParent(context, cayenneContext, parentAgEntity);
        }
        // delete all !!
        else {
            deleteAll(context, cayenneContext);
        }
    }
 

private <T extends DataObject> void deleteByParent(DeleteContext<T> context, ObjectContext cayenneContext, AgEntity<?> agParentEntity) {

        EntityParent<?> parent = context.getParent();
        Object parentObject = CayenneUtil.findById(cayenneContext, parent.getType(), agParentEntity, parent.getId().get());

        if (parentObject == null) {
            ObjEntity entity = cayenneContext.getEntityResolver().getObjEntity(parent.getType());
            throw new AgException(Response.Status.NOT_FOUND, "No parent object for ID '" + parent.getId()
                    + "' and entity '" + entity.getName() + "'");
        }

        Expression qualifier = CayenneUtil.parentQualifier(parent, cayenneContext.getEntityResolver());
        SelectQuery<?> select = SelectQuery.query(context.getType());
        select.andQualifier(qualifier);

        List<?> objects = cayenneContext.select(select);

        cayenneContext.deleteObjects(objects);
        cayenneContext.commitChanges();
    }
 

private <T extends DataObject> void checkExisting(
        ObjectContext objectContext,
        AgEntity<T> agEntity,
        Map<DbAttribute, Object> idByDbAttribute,
        Map<String, Object> idByAgAttribute) {

    ObjectSelect<DataRow> query = ObjectSelect.dataRowQuery(agEntity.getType());
    for (Map.Entry<DbAttribute, Object> e : idByDbAttribute.entrySet()) {
        query.and(ExpressionFactory.matchDbExp(e.getKey().getName(), e.getValue()));
    }

    if (query.selectOne(objectContext) != null) {
        throw new AgException(Response.Status.BAD_REQUEST, "Can't create '"
                + agEntity.getName()
                + "' with id "
                + CompoundObjectId.mapToString(idByAgAttribute)
                + " - already exists");
    }
}
 

@SuppressWarnings("unchecked")
private Object getOptionalExistingObject(Class<?> type, ObjectContext context, Object id) {

    ObjEntity entity = context.getEntityResolver().getObjEntity(type);

    // sanity checking...
    if (entity == null) {
        throw new AgException(Response.Status.INTERNAL_SERVER_ERROR, "Unknown entity class: " + type);
    }

    // TODO: should we start using optimistic locking on PK by default
    // instead of SELECT/DELETE|UPDATE?

    String idName = entity.getPrimaryKeyNames().iterator().next();
    ObjectIdQuery select = new ObjectIdQuery(new ObjectId(entity.getName(), idName, id));

    return Cayenne.objectForQuery(context, select);
}
 

@GET
@Path("test_mix_up_relations")
public DataResponse<E5> test_mix_up_relations(@Context UriInfo uriInfo) {

    ObjectContext context = AgRuntime.service(ICayennePersister.class, config).sharedContext();

    AgEntityOverlay<E5> o1 = AgEntity
            .overlay(E5.class)
            .redefineToMany(E5.E3S.getName(), E2.class, e5 ->
                    ObjectSelect.query(E2.class)
                            .where(ExpressionFactory.greaterDbExp(E2.ID__PK_COLUMN, Cayenne.longPKForObject(e5)))
                            .select(context)
            );

    AgEntityOverlay<E2> o2 = AgEntity
            .overlay(E2.class)
            .redefineToOne("ex", E3.class, e2 ->
                    SelectById.query(E3.class, Cayenne.intPKForObject(e2)).selectOne(context)
            );

    return Ag.select(E5.class, config)
            .entityOverlay(o1)
            .entityOverlay(o2)
            .uri(uriInfo)
            .get();
}
 

public DataFrame merge(ObjectContext context, DataFrame df) {

        Index sourceSubIndex = df
                .getColumnsIndex()
                .dropLabels(CreateOrUpdateSegment.TARGET_COLUMN, CreateOrUpdateSegment.TARGET_CREATED_COLUMN);

        Map<TargetAttribute, Set<Object>> fks = collectFks(df, sourceSubIndex);
        Map<TargetAttribute, Map<Object, Object>> related = fetchRelated(context, fks);

        Index changeTrackingIndex = df.getColumnsIndex().addLabels(CreateOrUpdateSegment.TARGET_CHANGED_COLUMN);

        return df
                .map(df.getColumnsIndex(), (f, t) -> resolveFks(f, t, related))
                // TODO: rebuild "$lm_target" column individually instead of rebuilding the entire DataFrame
                .map(changeTrackingIndex, (f, t) -> merge(f, t, sourceSubIndex))
                .filterRows(r -> (boolean) r.get(CreateOrUpdateSegment.TARGET_CHANGED_COLUMN))
                .dropColumns(CreateOrUpdateSegment.TARGET_CHANGED_COLUMN);
    }
 

private <T extends DataObject> void deleteById(DeleteContext<T> context, ObjectContext cayenneContext, AgEntity<T> agEntity) {

        for (AgObjectId id : context.getIds()) {
            Object o = CayenneUtil.findById(cayenneContext, context.getType(), agEntity, id.get());

            if (o == null) {
                ObjEntity entity = cayenneContext.getEntityResolver().getObjEntity(context.getType());
                throw new AgException(Response.Status.NOT_FOUND, "No object for ID '" + id + "' and entity '"
                        + entity.getName() + "'");
            }

            cayenneContext.deleteObject(o);
        }
        cayenneContext.commitChanges();
    }
 

private <T extends DataObject> void deleteAll(DeleteContext<?> context, ObjectContext cayenneContext) {
    ObjEntity e = cayenneContext.getEntityResolver().getObjEntity(context.getType());

    // TODO: is this kosher? All other deletes are done via Cayenne and
    // hence process all delete rules. This one does not
    cayenneContext.performQuery(new EJBQLQuery("delete from " + e.getName()));
}
 

@SuppressWarnings("unchecked")
public static <A> A findById(ObjectContext context, Class<A> type, AgEntity<?> agEntity, Object id) {
    ObjEntity entity = context.getEntityResolver().getObjEntity(type);

    // sanity checking...
    if (entity == null) {
        throw new AgException(Status.INTERNAL_SERVER_ERROR, "Unknown entity class: " + type);
    }

    if (id == null) {
        throw new AgException(Status.BAD_REQUEST, "No id specified");
    }

    if (id instanceof Map) {
        Map<String, Object> ids = (Map<String, Object>) id;
        DbEntity dbEntity = entity.getDbEntity();

        ObjectSelect<A> query = ObjectSelect.query(type);
        for (Map.Entry<String, Object> entry : ids.entrySet()) {
            query.and(ExpressionFactory.matchDbExp(dbEntity.getAttribute(entry.getKey()).getName(), entry.getValue()));
        }
        return query.selectOne(context);
    } else {
        // TODO: this will break if this is am ID attribute not mapped as ObjAttribute in Cayenne
        AgAttribute attribute = agEntity.getIds().iterator().next();
        return ObjectSelect.query(type, new ASTEqual(attribute.getPathExp(), id)).selectOne(context);
    }
}
 

protected <T extends DataObject> void createSingle(UpdateContext<T> context, ObjectRelator relator, EntityUpdate<T> u) {

        ObjectContext objectContext = CayenneUpdateStartStage.cayenneContext(context);
        DataObject o = objectContext.newObject(context.getType());
        Map<String, Object> idByAgAttribute = u.getId();

        // set explicit ID
        if (idByAgAttribute != null) {

            if (context.isIdUpdatesDisallowed() && u.isExplicitId()) {
                throw new AgException(Response.Status.BAD_REQUEST, "Setting ID explicitly is not allowed: " + idByAgAttribute);
            }

            ObjEntity objEntity = objectContext.getEntityResolver().getObjEntity(context.getType());
            DbEntity dbEntity = objEntity.getDbEntity();
            AgEntity agEntity = context.getEntity().getAgEntity();

            Map<DbAttribute, Object> idByDbAttribute = mapToDbAttributes(agEntity, idByAgAttribute);

            if (isPrimaryKey(dbEntity, idByDbAttribute.keySet())) {
                createSingleFromPk(objEntity, idByDbAttribute, o);
            } else {
                // need to make an additional check that the AgId is unique
                checkExisting(objectContext, agEntity, idByDbAttribute, idByAgAttribute);
                createSingleFromIdValues(objEntity, idByDbAttribute, idByAgAttribute, o);
            }
        }

        mergeChanges(u, o, relator);
        relator.relateToParent(o);
    }
 

protected <T extends DataObject> void doExecute(UnrelateContext<T> context) {

        ObjectContext cayenneContext = CayenneUnrelateStartStage.cayenneContext(context);

        if (context.getId() != null) {
            unrelateSingle(context, cayenneContext);
        } else {
            unrelateAll(context, cayenneContext);
        }
    }
 

private <T extends DataObject> void unrelateSingle(UnrelateContext<T> context, ObjectContext cayenneContext) {

        // validate relationship before doing anything else
        AgRelationship relationship = metadataService.getAgRelationship(
                context.getParent().getType(),
                context.getParent().getRelationship());

        DataObject parent = (DataObject) getExistingObject(context.getParent().getType(), cayenneContext, context
                .getParent().getId().get());

        Class<?> childType = relationship.getTargetEntity().getType();

        // among other things this call checks that the target exists
        DataObject child = (DataObject) getExistingObject(childType, cayenneContext, context.getId());

        if (relationship.isToMany()) {

            // sanity check...
            Collection<?> relatedCollection = (Collection<?>) parent.readProperty(relationship.getName());
            if (!relatedCollection.contains(child)) {
                throw new AgException(Response.Status.EXPECTATION_FAILED, "Source and target are not related");
            }

            parent.removeToManyTarget(relationship.getName(), child, true);
        } else {

            // sanity check...
            if (parent.readProperty(relationship.getName()) != child) {
                throw new AgException(Response.Status.EXPECTATION_FAILED, "Source and target are not related");
            }

            parent.setToOneTarget(relationship.getName(), null, true);
        }

        cayenneContext.commitChanges();
    }
 

private <T extends DataObject> void unrelateAll(UnrelateContext<T> context, ObjectContext cayenneContext) {
    // validate relationship before doing anything else
    AgRelationship agRelationship = metadataService.getAgRelationship(
            context.getParent().getType(),
            context.getParent().getRelationship());

    DataObject parent = (DataObject) getExistingObject(context.getParent().getType(), cayenneContext, context
            .getParent().getId().get());

    if (agRelationship.isToMany()) {

        // clone relationship before we start deleting to avoid concurrent
        // modification of the iterator, and to be able to batch-delete
        // objects if needed
        @SuppressWarnings("unchecked")
        Collection<DataObject> relatedCollection = new ArrayList<>(
                (Collection<DataObject>) parent.readProperty(agRelationship.getName()));

        for (DataObject o : relatedCollection) {
            parent.removeToManyTarget(agRelationship.getName(), o, true);
        }

    } else {

        DataObject target = (DataObject) parent.readProperty(agRelationship.getName());
        if (target != null) {
            parent.setToOneTarget(agRelationship.getName(), null, true);
        }
    }

    cayenneContext.commitChanges();
}
 

private Object getExistingObject(Class<?> type, ObjectContext context, Object id) {

        Object object = getOptionalExistingObject(type, context, id);
        if (object == null) {
            ObjEntity entity = context.getEntityResolver().getObjEntity(type);
            throw new AgException(Response.Status.NOT_FOUND, "No object for ID '" + id + "' and entity '"
                    + entity.getName() + "'");
        }

        return object;
    }
 

@Before
public void initAgDataMap() {

    ObjectContext sharedContext = runtime.newContext();

    this.mockCayennePersister = mock(ICayennePersister.class);
    when(mockCayennePersister.entityResolver()).thenReturn(runtime.getChannel().getEntityResolver());
    when(mockCayennePersister.sharedContext()).thenReturn(sharedContext);
    when(mockCayennePersister.newContext()).thenReturn(runtime.newContext());

    this.metadataService = new MetadataService(createEntityCompilers());
    this.resourceParser = new ResourceParser(metadataService);
    this.resourceMetadataService = createResourceMetadataService();
}
 

@Before
public void initAgDataMap() {

    ObjectContext sharedContext = runtime.newContext();

    this.mockCayennePersister = mock(ICayennePersister.class);
    when(mockCayennePersister.entityResolver()).thenReturn(runtime.getChannel().getEntityResolver());
    when(mockCayennePersister.sharedContext()).thenReturn(sharedContext);
    when(mockCayennePersister.newContext()).thenReturn(runtime.newContext());

    this.metadataService = new MetadataService(createEntityCompilers());
    this.resourceParser = new ResourceParser(metadataService);
    this.resourceMetadataService = createResourceMetadataService();
}
 

@Override
public GraphDiff onSync(ObjectContext originatingContext, GraphDiff changes, int syncType, DataChannelFilterChain filterChain) {

    if (syncType == DataChannel.FLUSH_CASCADE_SYNC) {
        commitCounter++;
    }

    return filterChain.onSync(originatingContext, changes, syncType);
}
 

public JdbcExtractor(ObjectContext context, RowAttribute[] rowHeader, String sqlTemplate,
                     CapsStrategy capsStrategy) {
    this.context = context;
    this.sqlTemplate = sqlTemplate;
    this.capsStrategy = capsStrategy;
    this.rowHeader = rowHeader;
}
 

protected BatchProcessor<T> createBatchProcessor(Execution execution) {

        Index columns = Index.forLabels(DeleteSegment.TARGET_COLUMN);

        return rows -> {

            // executing in the select context..
            ObjectContext context = rows.get(0).getObjectContext();
            DataFrame df = DataFrame.newFrame(columns)
                    // TODO: when we can upgrade to 0.7, switch to Series.forData(rows)
                    .columns(Series.forData(rows.toArray()));
            processor.process(execution, new DeleteSegment<>(context, df));
        };
    }
 

private Map<TargetAttribute, Map<Object, Object>> fetchRelated(
        ObjectContext context,
        Map<TargetAttribute, Set<Object>> fkMap) {

    if (fkMap.isEmpty()) {
        return Collections.emptyMap();
    }

    // map of *path* to map of *pk* to *object*...
    Map<TargetAttribute, Map<Object, Object>> related = new HashMap<>();

    fkMap.forEach((a, fks) -> {

        if (!fks.isEmpty()) {

            TargetAttribute relatedPk = a.getForeignKey().get().getTarget();
            String relatedPath = relatedPk.getNormalizedPath().substring(ASTDbPath.DB_PREFIX.length());
            String relatedEntityName = relatedPk.getEntity().getName();

            Map<Object, Object> relatedFetched = new HashMap<>((int) (fks.size() / 0.75));
            ObjectSelect
                    .query(Object.class)
                    .entityName(relatedEntityName)
                    .where(ExpressionFactory.inDbExp(relatedPath, fks))
                    .select(context)
                    // map by fk value (which is a PK of the matched object of course)
                    .forEach(r -> relatedFetched.put(Cayenne.pkForObject((Persistent) r), r));

            related.put(a, relatedFetched);
        }
    });

    return related;
}
 

public DataFrame map(
        ObjectContext context,
        DataFrame sources,
        DataFrame targets) {

    Hasher lkm = r -> r.get(CreateOrUpdateSegment.KEY_COLUMN);
    Hasher rkm = r -> mapper.keyForTarget((DataObject) r.get(CreateOrUpdateSegment.TARGET_COLUMN));

    return sources
            .leftJoin().on(lkm, rkm).with(targets)
            .addColumn(CreateOrUpdateSegment.TARGET_CREATED_COLUMN, r -> isCreated(r.get(CreateOrUpdateSegment.TARGET_COLUMN)))
            .convertColumn(CreateOrUpdateSegment.TARGET_COLUMN, r -> createIfMissing(r, context));
}
 

public DataFrame match(ObjectContext context, DataFrame df) {

        Map<Object, Expression> expressions = new LinkedHashMap<>();

        df.forEach(r -> expressions.computeIfAbsent(r.get(CreateOrUpdateSegment.KEY_COLUMN),
                key -> mapper.expressionForKey(key)));

        // no keys (?)
        if (expressions.isEmpty()) {
            return toDataFrame(Collections.emptyList());
        } else {
            return toDataFrame(ObjectSelect.query(type).where(ExpressionFactory.or(expressions.values())).select(context));
        }
    }
 

@Before
public void deleteSourceData() {

	ObjectContext context = srcStack.newContext();

	// first query in a test set will also load the schema...

	context.performGenericQuery(new SQLTemplate(Object.class, "DELETE from utest.etl1"));
	context.performGenericQuery(new SQLTemplate(Object.class, "DELETE from utest.etl3"));
	context.performGenericQuery(new SQLTemplate(Object.class, "DELETE from utest.etl2"));
	context.performGenericQuery(new SQLTemplate(Object.class, "DELETE from utest.etl4"));
	context.performGenericQuery(new SQLTemplate(Object.class, "DELETE from utest.etl5"));
}
 

@Test
public void testSharedContext() {
    ObjectContext context = connector.sharedContext();
    assertNotNull(context);

    SQLExec.query("INSERT INTO utest.etl1 (NAME) VALUES ('a')").execute(context);
    assertEquals(1, srcScalar("SELECT count(1) from utest.etl1"));
}
 

@Test
public void testCayenneJava8Support() {
    ObjectContext context = connector.sharedContext();

    ValueObjectTypeRegistry typeRegistry = context.getEntityResolver().getValueObjectTypeRegistry();
    ValueObjectType<LocalDateTime, ?> vt = typeRegistry.getValueType(LocalDateTime.class);
    assertTrue(vt instanceof LocalDateTimeValueType);
}
 

@Test
public void testEncoder_FilteredToOne() throws IOException {

    EntityEncoderFilter filter = EntityEncoderFilter.forAll()
            .objectCondition((p, o, d) -> o instanceof E2 && Cayenne.intPKForObject((E2) o) != 7
                    ? false : d.willEncode(p, o)
            )
            .encoder((p, o, out, d) -> o instanceof E2 && Cayenne.intPKForObject((E2) o) != 7
                    ? false : d.encode(p, o, out))
            .build();


    RootResourceEntity<E3> e3Descriptor = getResourceEntity(E3.class);
    e3Descriptor.getEntityEncoderFilters().add(filter);
    e3Descriptor.includeId();

    NestedResourceEntity<E2> e2Descriptor = getChildResourceEntity(E2.class, e3Descriptor, E3.E2.getName());
    e2Descriptor.getEntityEncoderFilters().add(filter);
    e2Descriptor.includeId();
    e3Descriptor.getChildren().put(E3.E2.getName(), e2Descriptor);

    ObjectContext context = cayenneService.newContext();

    E2 e21 = new E2();
    e21.setObjectId(new ObjectId("E2", E2.ID__PK_COLUMN, 7));
    context.registerNewObject(e21);

    E3 e31 = new E3();
    e31.setObjectId(new ObjectId("E3", E3.ID__PK_COLUMN, 5));
    context.registerNewObject(e31);
    e31.setE2(e21);

    // saves result set in ResourceEntity
    e3Descriptor.setResult(Collections.singletonList(e31));
    e2Descriptor.setToOneResult(new SimpleObjectId(5), e21);

    assertEquals("{\"success\":true,\"data\":[{\"id\":5,\"e2\":{\"id\":7},\"e2_id\":7}],\"total\":1}",
            toJson(e31, e3Descriptor));

    E2 e22 = new E2();
    e22.setObjectId(new ObjectId("E2", E2.ID__PK_COLUMN, 8));
    context.registerNewObject(e22);

    E3 e32 = new E3();
    e32.setObjectId(new ObjectId("E3", E3.ID__PK_COLUMN, 6));
    context.registerNewObject(e32);
    e32.setE2(e22);

    // saves result set in ResourceEntity
    e3Descriptor.setResult(Collections.singletonList(e32));
    e2Descriptor.setToOneResult(new SimpleObjectId(6), e22);

    assertEquals("{\"success\":true,\"data\":[{\"id\":6}],\"total\":1}", toJson(e32, e3Descriptor));
}
 

@Override
public ObjectContext sharedContext() {
	return sharedContext;
}
 

@Override
public ObjectContext newContext() {
	return runtime.newContext();
}
 

@Test
public void testGetRootEncoder_ExcludedRelationshipAttributes() {

    RootResourceEntity<E2> descriptor = getResourceEntity(E2.class);
    descriptor.includeId();

    NestedResourceEntity<E3> e3Descriptor = getChildResourceEntity(E3.class, descriptor, E2.E3S.getName());
    e3Descriptor.includeId();
    appendAttribute(e3Descriptor, E3.NAME, String.class);

    descriptor.getChildren().put(E2.E3S.getName(), e3Descriptor);

    ObjectContext context = mockCayennePersister.newContext();
    E2 e2 = new E2();
    e2.setObjectId(new ObjectId("E2", E2.ID__PK_COLUMN, 7));
    e2.setName("XYZ");
    e2.setAddress("bla bla street");
    context.registerNewObject(e2);

    E3 e31 = new E3();
    e31.setObjectId(new ObjectId("E3", E3.ID__PK_COLUMN, 5));
    e31.setName("31");
    e31.setPhoneNumber("+12345678");
    context.registerNewObject(e31);
    e2.addToE3s(e31);

    E3 e32 = new E3();
    e32.setObjectId(new ObjectId("E3", E3.ID__PK_COLUMN, 6));
    e32.setName("32");
    e31.setPhoneNumber("+87654321");
    context.registerNewObject(e32);
    e2.addToE3s(e32);

    // saves result set in ResourceEntity
    descriptor.setResult(Collections.singletonList(e2));
    e3Descriptor.addToManyResult(new SimpleObjectId(7), e31);
    e3Descriptor.addToManyResult(new SimpleObjectId(7), e32);

    assertEquals("{\"data\":[{\"id\":7,\"e3s\":[{\"id\":5,\"name\":\"31\"},{\"id\":6,\"name\":\"32\"}]}],\"total\":1}",
            toJson(e2, descriptor));
}