Java DataTarget类代码示例

import com.holonplatform.core.datastore.DataTarget; //导入依赖的package包/类
@Test
public void testQueryAggregateProjection() {

	final DataTarget<TestJpaDomain> DataTarget = JpaTarget.of(TestJpaDomain.class);

	Optional<Long> key = getDatastore().query().target(DataTarget).findOne(KEY.max());
	assertTrue(key.isPresent());
	assertEquals(new Long(2), key.get());

	key = getDatastore().query().target(DataTarget).findOne(KEY.min());
	assertTrue(key.isPresent());
	assertEquals(new Long(1), key.get());

	Optional<Long> sum = getDatastore().query().target(DataTarget).findOne(KEY.sum());
	assertTrue(sum.isPresent());
	assertEquals(new Long(3), sum.get());

	Optional<Long> count = getDatastore().query().target(DataTarget).findOne(KEY.count());
	assertEquals(new Long(2), count.get());
}
 

import com.holonplatform.core.datastore.DataTarget; //导入依赖的package包/类
@Test
public void testQueryStream() {

	List<String> results = getDatastore().query().target(DataTarget.named(TestJpaDomain.class.getName()))
			.sort(KEY.asc()).stream(KEY).map((r) -> r.toString()).collect(Collectors.toList());

	assertNotNull(results);
	assertEquals(2, results.size());

	String res = results.get(0);
	assertNotNull(res);
	assertEquals("1", res);

	List<Long> results2 = getDatastore().query().target(QueryDslTarget.of(QTestJpaDomain.testJpaDomain))
			.sort(KEY.asc()).stream(KEY, STR).map((r) -> r.getValue(KEY)).collect(Collectors.toList());

	Long lng = results2.get(0);
	assertNotNull(lng);
	assertEquals(new Long(1), lng);

}
 

import com.holonplatform.core.datastore.DataTarget; //导入依赖的package包/类
public void selectable9() {
	// tag::selectable9[]
	Datastore datastore = obtainDatastore();

	final PathProperty<Long> ID = PathProperty.create("id", Long.class);
	final PathProperty<String> DESCRIPTION = PathProperty.create("description", String.class);

	SingleSelect<Long> singleSelect = Components.input.singleSelect(ID) // <1>
			.dataSource(datastore, DataTarget.named("testData"), PropertySet.of(ID, DESCRIPTION)) // <2>
			.itemCaptionGenerator(propertyBox -> propertyBox.getValue(DESCRIPTION)) // <3>
			.build();

	singleSelect.setValue(Long.valueOf(1)); // <4>
	Long selectedId = singleSelect.getValue(); // <5>

	singleSelect.refresh(); // <6>
	// end::selectable9[]
}
 

import com.holonplatform.core.datastore.DataTarget; //导入依赖的package包/类
/**
 * Create a JPA batch insert.
 * @param context Datastore context
 * @param beanIntrospector Bean introspector
 * @param target Data target
 * @param propertySet Property set
 * @param writeOptions Write options
 */
@SuppressWarnings("unchecked")
public JpaBulkInsert(JpaDatastoreCommodityContext context, BeanIntrospector beanIntrospector, DataTarget<?> target,
		PropertySet<?> propertySet, WriteOption[] writeOptions) {
	super();

	ObjectUtils.argumentNotNull(context, "JpaDatastoreCommodityContext must be not null");
	ObjectUtils.argumentNotNull(target, "Data target must be not null");
	ObjectUtils.argumentNotNull(propertySet, "PropertySet must be not null");

	this.context = context;
	this.beanIntrospector = beanIntrospector;
	this.target = target;
	this.propertySet = propertySet;
	this.writeOptions = writeOptions;

	// inherit resolvers
	context.getExpressionResolvers().forEach(r -> expressionResolverRegistry.addExpressionResolver(r));
}
 

import com.holonplatform.core.datastore.DataTarget; //导入依赖的package包/类
public void selectable11() {
	// tag::selectable11[]
	Datastore datastore = obtainDatastore();

	final PathProperty<Long> ID = PathProperty.create("id", Long.class);
	final PathProperty<String> DESCRIPTION = PathProperty.create("description", String.class);
	final DataTarget<?> TARGET = DataTarget.named("testData");
	final PropertySet<?> PROPERTIES = PropertySet.of(ID, DESCRIPTION);

	SingleSelect<Long> singleSelect = Components.input.singleSelect(ID)
			.dataSource(datastore, DataTarget.named("testData"), PROPERTIES)
			.itemConverter(
					value -> datastore.query().target(TARGET).filter(ID.eq(value)).findOne(PROPERTIES).orElse(null)) // <1>
			.build();
	// end::selectable11[]
}
 

import com.holonplatform.core.datastore.DataTarget; //导入依赖的package包/类
@Override
public OperationResult update(DataTarget<?> target, PropertyBox propertyBox, WriteOption... options) {

	ObjectUtils.argumentNotNull(target, "DataTarget must be not null");
	ObjectUtils.argumentNotNull(propertyBox, "PropertyBox must be not null");

	return withEntityManager(entityManager -> {

		// get entity class
		Class<?> entity = getEntityClass(target, entityManager);

		// create a new instance
		Object instance = entity.newInstance();

		// merge entity
		entityManager.merge(getBeanIntrospector().write(propertyBox, instance));

		// check auto-flush
		if (isAutoFlush() || JpaDatastoreUtils.isFlush(options)) {
			entityManager.flush();
		}

		return OperationResult.builder().type(OperationType.UPDATE).affectedCount(1).build();

	});
}
 

import com.holonplatform.core.datastore.DataTarget; //导入依赖的package包/类
@Test
@Transactional
@Rollback
public void testGeneratedId() {
	final PathProperty<Long> CODE = PathProperty.create("code", Long.class);
	final PathProperty<String> VALUE = PathProperty.create("value", String.class);

	final DataTarget<TestGeneratedId> TARGET = JpaTarget.of(TestGeneratedId.class);

	OperationResult result = getDatastore().insert(TARGET,
			PropertyBox.builder(CODE, VALUE).set(VALUE, "Test value").build(), JpaWriteOption.FLUSH);
	assertEquals(1, result.getAffectedCount());
	assertEquals(1, result.getInsertedKeys().size());

	assertEquals(Long.valueOf(1), result.getInsertedKeys().values().iterator().next());

	// bring back ids
	PropertyBox box = PropertyBox.builder(CODE, VALUE).set(VALUE, "Test v2").build();
	result = getDatastore().insert(TARGET, box, JpaWriteOption.FLUSH, DefaultWriteOption.BRING_BACK_GENERATED_IDS);
	assertEquals(1, result.getAffectedCount());
	assertEquals(1, result.getInsertedKeys().size());
	assertEquals(Long.valueOf(2), box.getValue(CODE));
}
 

import com.holonplatform.core.datastore.DataTarget; //导入依赖的package包/类
private void findParents(List<String> parents, String name) {
	if (name != null) {

		final DataTarget<?> R_TARGET = DataTarget.named("test_recur");

		RelationalTarget<?> group_alias_1 = RelationalTarget.of(R_TARGET).alias("g1");
		RelationalTarget<?> group_alias_2 = RelationalTarget.of(R_TARGET).alias("g2");

		QueryFilter f1 = group_alias_1.property(TestRecur.PROPERTIES.requireProperty("parent")).isNotNull();
		QueryFilter f2 = group_alias_2.property(TestRecur.PROPERTIES.requireProperty("name"))
				.eq(group_alias_1.property(TestRecur.PROPERTIES.requireProperty("parent")));

		RelationalTarget<?> target = group_alias_1.innerJoin(group_alias_2).on(f1.and(f2)).add();

		List<String> group_parents = getDatastore().query().target(target)
				.filter(group_alias_1.property(TestRecur.PROPERTIES.requireProperty("name")).eq(name))
				.list(group_alias_2.property(TestRecur.PROPERTIES.requireProperty("name")));

		if (!group_parents.isEmpty()) {
			parents.addAll(group_parents);
			for (String p : group_parents) {
				findParents(parents, p);
			}
		}
	}
}
 

import com.holonplatform.core.datastore.DataTarget; //导入依赖的package包/类
@PostConstruct
public void init() {
	Components.configure(this)
			// set full to view content
			.fullSize().spacing()
			.add(Components.button().caption("Add new").styleName(ValoTheme.BUTTON_PRIMARY)
					// navigate to "manage" view
					.onClick(e -> ViewNavigator.require().toView("manage").navigate()).build())
			// build and add listing
			.addAndExpandFull(listing = Components.listing.properties(MProduct.PRODUCT)
					// setup data source using Datastore with 'products' table name target and product ID as pk
					.dataSource(datastore, DataTarget.named("products"), MProduct.ID)
					// disable auto refresh: will be triggered on view enter
					.autoRefresh(false)
					// when user clicks on a row, open the 'view' named View providing product id parameter
					.withItemClickListener((i, p, e) -> ViewNavigator.require().toView("view")
							.withParameter("id", i.getValue(MProduct.ID)).navigate())
					// set full size and build
					.fullSize().build());
}
 

import com.holonplatform.core.datastore.DataTarget; //导入依赖的package包/类
@SuppressWarnings({ "rawtypes", "unchecked" })
public void subquery1() {
	// tag::subquery1[]
	Datastore datastore = getDatastore(); // this is supposed to be a relational Datastore implementation

	final DataTarget TARGET1 = DataTarget.named("testTarget1");
	final PathProperty<Integer> PROPERTY1 = TARGET1.property("test", Integer.class);

	final DataTarget TARGET2 = DataTarget.named("testTarget2");
	final PathProperty<Integer> PROPERTY2 = TARGET2.property("test", Integer.class);

	SubQuery<Integer> subQuery = SubQuery.create(datastore).target(TARGET2).filter(PROPERTY1.goe(1))
			.select(PROPERTY1); // <1>

	Stream<Integer> results = datastore.query().target(TARGET1).filter(PROPERTY2.in(subQuery)).stream(PROPERTY2); // <2>
	// end::subquery1[]
}
 

import com.holonplatform.core.datastore.DataTarget; //导入依赖的package包/类
@SuppressWarnings({ "rawtypes", "unchecked" })
public void subquery2() {
	// tag::subquery2[]
	Datastore datastore = getDatastore(); // this is supposed to be a relational Datastore implementation

	final DataTarget TARGET1 = DataTarget.named("testTarget1");
	final PathProperty<Integer> PROPERTY1 = TARGET1.property("test", Integer.class);

	final DataTarget TARGET2 = DataTarget.named("testTarget2");
	final PathProperty<Integer> PROPERTY2 = TARGET2.property("test", Integer.class);

	Stream<Integer> results = datastore.query().target(TARGET1)
			.filter(SubQuery.create(datastore).target(TARGET2).filter(PROPERTY2.eq(PROPERTY1)).exists())
			.stream(PROPERTY2); // <1>

	results = datastore.query().target(TARGET1)
			.filter(SubQuery.create(datastore).target(TARGET2).filter(PROPERTY2.eq(PROPERTY1)).notExists())
			.stream(PROPERTY2); // <2>
	// end::subquery2[]
}
 

import com.holonplatform.core.datastore.DataTarget; //导入依赖的package包/类
@SuppressWarnings({ "rawtypes", "unchecked" })
public void joins() {
	// tag::joins[]
	final DataTarget TARGET1 = DataTarget.named("testTarget1");
	final PathProperty<Integer> PROPERTY1 = TARGET1.property("test", Integer.class);

	final DataTarget TARGET2 = DataTarget.named("testTarget2");
	final PathProperty<Integer> PROPERTY2 = TARGET2.property("test", Integer.class);

	RelationalTarget<String> RT = RelationalTarget.of(TARGET1) // <1>
			.join(TARGET2, JoinType.INNER).on(PROPERTY2.eq(PROPERTY1)).add(); // <2>

	RT = RelationalTarget.of(TARGET1).innerJoin(TARGET2).on(PROPERTY2.eq(PROPERTY1)).add(); // <3>
	RT = RelationalTarget.of(TARGET1).leftJoin(TARGET2).on(PROPERTY2.eq(PROPERTY1)).add(); // <4>
	RT = RelationalTarget.of(TARGET1).rightJoin(TARGET2).on(PROPERTY2.eq(PROPERTY1)).add(); // <5>

	Stream<Integer> results = getDatastore().query().target(RT).stream(PROPERTY1); // <6>
	// end::joins[]
}
 

import com.holonplatform.core.datastore.DataTarget; //导入依赖的package包/类
public void listing10() {
	// tag::listing10[]
	Datastore datastore = getDatastore();

	PropertyListing listing = Components.listing.properties(PROPERTIES) //
			.dataSource(datastore, DataTarget.named("test"), ID) // <1>
			.commitHandler((addedItems, modifiedItems, removedItems) -> { // <2>
				// ...
			}).build();

	final PropertyBox ITEM = PropertyBox.builder(PROPERTIES).set(ID, 777L).set(DESCRIPTION, "A description")
			.build();

	listing.addItem(ITEM); // <3>

	listing.refreshItem(ITEM); // <4>

	listing.removeItem(ITEM); // <5>
	// end::listing10[]
}
 

import com.holonplatform.core.datastore.DataTarget; //导入依赖的package包/类
@Test
public void testQueryDefinition() {

	DefaultQueryDefinition qd = new DefaultQueryDefinition();
	qd.setTarget(DataTarget.named("target"));

	assertTrue(qd.getTarget().isPresent());
	assertEquals("target", qd.getTarget().get().getName());

	qd.setLimit(Integer.valueOf(10));
	qd.setOffset(Integer.valueOf(20));

	assertTrue(qd.getLimit().isPresent());
	assertTrue(qd.getLimit().isPresent());
	assertEquals(new Integer(10), qd.getLimit().get());
	assertEquals(new Integer(20), qd.getOffset().get());

	qd.addFilter(TestPropertySet.NAME.isNotNull());
	assertTrue(qd.getFilter().isPresent());

	QuerySort qs = TestPropertySet.NAME.asc();
	qd.addSort(qs);
	assertEquals(qs, qd.getSort().get());

}
 

import com.holonplatform.core.datastore.DataTarget; //导入依赖的package包/类
public void listing11() {
	// tag::listing11[]
	Datastore datastore = getDatastore();

	PropertyListing listing = Components.listing.properties(PROPERTIES) //
			.dataSource(datastore, DataTarget.named("test"), ID) //
			.buffered(true) // <1>
			.build();

	final PropertyBox ITEM = PropertyBox.builder(PROPERTIES).set(ID, 777L).set(DESCRIPTION, "A description")
			.build();

	listing.addItem(ITEM); // <2>
	listing.refreshItem(ITEM); // <3>
	listing.removeItem(ITEM); // <4>

	listing.commit(); // <5>
	listing.discard(); // <6>
	// end::listing11[]
}