org.hibernate.Criteria.createAlias java code examples

Refine search

 Criteria c = session.createCriteria(Cat.class);
c.createAlias("mother.kind", "motherKind");
c.addOrder(Order.asc("motherKind.value"));
return c.list();

 Criteria crit = getSession().createCriteria(Discussion.class);
crit.createAlias("participants", "p");

crit.add(Restrictions.eq("p.elements", portalUsername));

protected List<T> findListByCriterionWithAlias(String path, String alias,
                        JoinType type, Criterion criterion) {
 String className = getSimpleClassName();
 LOG.trace("Searching {} entities by criterion [{}] ", className, criterion);
 Criteria criteria = getCriteria();
 if (type == null) {
  criteria.createAlias(path, alias);
 } else {
  criteria.createAlias(path, alias, type);
 }
 criteria.add(criterion);
 List<T> resultList = criteria.list();
 if (resultList == null) {
  resultList = Collections.emptyList();
 }
 return resultList;
}

@Override
public List<CtlSchema> findAllByMetaInfoId(String metaInfoId) {
 LOG.debug("Searching available version of ctl schema by meta info id [{}]", metaInfoId);
 Criteria criteria = getCriteria()
   .createAlias(CTL_SCHEMA_META_INFO_PROPERTY, CTL_SCHEMA_META_INFO_ALIAS)
   .add(Restrictions.eq(CTL_SCHEMA_META_INFO_ALIAS_ID, Long.valueOf(metaInfoId)))
   .addOrder(Order.asc(CTL_SCHEMA_VERSION));
 List<CtlSchema> schemas = findListByCriteria(criteria);
 if (LOG.isTraceEnabled()) {
  LOG.trace("Search result: [{}].", Arrays.toString(schemas.toArray()));
 } else {
  LOG.debug("Search result: [{}].", schemas.size());
 }
 return schemas;
}

@Override
public List<EndpointGroup> findEndpointGroupsByTopicIdAndAppId(String appId, String topicId) {
 List<EndpointGroup> groups = Collections.emptyList();
 LOG.debug("Searching endpoint group by application id [{}] and topic id [{}]", appId, topicId);
 if (isNotBlank(appId)) {
  Criteria criteria = getCriteria();
  criteria.createAlias(APPLICATION_PROPERTY, APPLICATION_ALIAS);
  criteria.createAlias(TOPICS_PROPERTY, TOPIC_ALIAS);
  criteria.add(Restrictions.and(
    Restrictions.eq(APPLICATION_REFERENCE, Long.valueOf(appId)),
    Restrictions.eq(TOPIC_REFERENCE, Long.valueOf(topicId))));
  groups = findListByCriteria(criteria);
 }
 if (LOG.isTraceEnabled()) {
  LOG.trace("[{}] Search result: {}.", appId, Arrays.toString(groups.toArray()));
 } else {
  LOG.debug("[{}] Search result: {}.", appId, groups.size());
 }
 return groups;
}

@Override
public EndpointProfileSchema findLatestByAppId(String appId) {
 EndpointProfileSchema latestSchema = null;
 LOG.debug("Searching latest profile schema by application id [{}] ", appId);
 if (isNotBlank(appId)) {
  Criteria criteria = getCriteria().createAlias(APPLICATION_PROPERTY, APPLICATION_ALIAS)
    .add(Restrictions.eq(APPLICATION_REFERENCE, Long.valueOf(appId)))
    .addOrder(Order.desc(VERSION_PROPERTY)).setMaxResults(FIRST);
  latestSchema = findOneByCriteria(criteria);
 }
 if (LOG.isTraceEnabled()) {
  LOG.trace("[{}] Search result: {}.", appId, latestSchema);
 } else {
  LOG.debug("[{}] Search result: {}.", appId, latestSchema != null);
 }
 return latestSchema;
}

@Override
public Configuration findLatestActiveBySchemaIdAndGroupId(String schemaId, String groupId) {
 Configuration configuration = null;
 LOG.debug("Searching latest active configuration by configuration schema id [{}] "
     + "and group id [{}]",
   schemaId, groupId);
 if (isNotBlank(schemaId) && isNotBlank(groupId)) {
  Criteria criteria = getCriteria();
  criteria.createAlias(CONFIGURATION_SCHEMA_PROPERTY, CONFIGURATION_SCHEMA_ALIAS);
  criteria.createAlias(ENDPOINT_GROUP_PROPERTY, ENDPOINT_GROUP_ALIAS);
  criteria.add(Restrictions.and(
    Restrictions.eq(ENDPOINT_GROUP_REFERENCE, Long.valueOf(groupId)),
    Restrictions.eq(CONFIGURATION_SCHEMA_REFERENCE, Long.valueOf(schemaId)),
    Restrictions.eq(STATUS_PROPERTY, UpdateStatus.ACTIVE)));
  configuration = findOneByCriteria(criteria);
 }
 if (LOG.isTraceEnabled()) {
  LOG.trace("[{},{}] Search result: {}.", schemaId, groupId, configuration);
 } else {
  LOG.debug("[{},{}] Search result: {}.", schemaId, groupId, configuration != null);
 }
 return configuration;
}

 Criteria criteria = currentSession.createCriteria(Professor.class, "professor");
  criteria.createAlias("professor.students", "student");
  criteria.createAlias("student.assigments", "assigment");
  criteria.add(Restrictions.eqProperty("professor.id", "student.profid"));
  criteria.add(Restrictions.eqProperty("assigment.studentid", "student.profid"));
  criteria.add(Restrictions.eq("id", 2411));
return criteria.list();

List<Object[]> result = session.createCriteria( Category.class, "c" ).createAlias( "products", "p" )
    .setProjection(
        Projections.projectionList()
    .setFirstResult( 1 ).setMaxResults( 3 ).list();

protected T findOneByCriterionWithAlias(String path, String alias, Criterion criterion) {
 String className = getSimpleClassName();
 LOG.trace("Searching {} entity by criterion [{}] ", className, criterion);
 Criteria criteria = getCriteria();
 criteria.createAlias(path, alias);
 criteria.add(criterion);
 return (T) criteria.uniqueResult();
}

@Override
public LogSchema findLatestLogSchemaByAppId(String applicationId) {
 LOG.debug("Searching latest log schema  by application id [{}]", applicationId);
 LogSchema logSchema = null;
 if (isNotBlank(applicationId)) {
  Criteria criteria = getCriteria();
  criteria.createAlias(APPLICATION_PROPERTY, APPLICATION_ALIAS);
  Criterion criterion = Restrictions.eq(APPLICATION_REFERENCE, Long.valueOf(applicationId));
  logSchema = (LogSchema) criteria.add(criterion).addOrder(Order.desc(VERSION_PROPERTY))
    .setMaxResults(FIRST).uniqueResult();
 }
 if (LOG.isTraceEnabled()) {
  LOG.trace("[{}] Search result: {}.", applicationId, logSchema);
 } else {
  LOG.debug("[{}] Search result: {}.", applicationId, logSchema != null);
 }
 return logSchema;
}

 @Override
 public List<ApplicationEventFamilyMap> findByEcfIdAndVersion(String ecfId, int version) {
  LOG.debug("Searching application event family maps by event class family id [{}] and "
       + "version [{}] ", ecfId, version);
  Criteria criteria = getCriteria();
  criteria.createAlias(ECF_PROPERTY, ECF_ALIAS);
  criteria.add(Restrictions.and(
    Restrictions.eq(ECF_REFERENCE, Long.valueOf(ecfId)),
    Restrictions.eq(VERSION_PROPERTY, version)));
  List<ApplicationEventFamilyMap> maps = findListByCriteria(criteria);
  if (LOG.isTraceEnabled()) {
   LOG.trace("[{},{}] Search result: {}.", ecfId, version, Arrays.toString(maps.toArray()));
  } else {
   LOG.debug("[{},{}] Search result: {}.", ecfId, version, maps.size());
  }
  return maps;
 }
}

public List<PayoutDetails> getPayoutDetails(AdvisorReportForm advisorReportForm) {
   Criteria criteria = getSession().createCriteria(PayoutDetails.class);
   if (advisorReportForm.getAdvisorId() != null && advisorReportForm.getAdvisorId() > 0) {
     criteria.add(Restrictions.eq("advisorId", advisorReportForm.getAdvisorId().toString()));
   }
   criteria.createAlias("payoutHeader", "header")
       .add(Restrictions.between("header.chequeIssuedDate", advisorReportForm.getFromDate(), advisorReportForm.getToDate()));        
   return criteria.list();
 }

    .createCriteria( Item.class )
    .addOrder( org.hibernate.criterion.Order.asc( "this.name" ) )
    .createAlias( "this.bids", "i_bid", JoinType.LEFT_OUTER_JOIN )
    .setProjection(
        Projections.projectionList().add( Projections.property( "this.name" ), "item_name" )
criteria.list();

@Override
public ConfigurationSchema findLatestByApplicationId(String appId) {
 ConfigurationSchema latestSchema = null;
 LOG.debug("Searching latest configuration schema by application id [{}] ", appId);
 if (isNotBlank(appId)) {
  Criteria criteria = getCriteria().createAlias(APPLICATION_PROPERTY, APPLICATION_ALIAS)
    .add(Restrictions.eq(APPLICATION_REFERENCE, Long.valueOf(appId)))
    .addOrder(Order.desc(VERSION_PROPERTY))
    .setMaxResults(FIRST);
  latestSchema = findOneByCriteria(criteria);
 }
 if (LOG.isTraceEnabled()) {
  LOG.trace("[{}] Search result: {}.", appId, latestSchema);
 } else {
  LOG.debug("[{}] Search result: {}.", appId, latestSchema != null);
 }
 return latestSchema;
}

@Override
public Configuration findInactiveBySchemaIdAndGroupId(String schemaId, String groupId) {
 Configuration configuration = null;
 LOG.debug("Searching inactive configuration by configuration schema id [{}] and "
     + "group id [{}] ",
   schemaId, groupId);
 if (isNotBlank(schemaId) && isNotBlank(groupId)) {
  Criteria criteria = getCriteria();
  criteria.createAlias(CONFIGURATION_SCHEMA_PROPERTY, CONFIGURATION_SCHEMA_ALIAS);
  criteria.createAlias(ENDPOINT_GROUP_PROPERTY, ENDPOINT_GROUP_ALIAS);
  criteria.add(Restrictions.and(
    Restrictions.eq(ENDPOINT_GROUP_REFERENCE, Long.valueOf(groupId)),
    Restrictions.eq(CONFIGURATION_SCHEMA_REFERENCE, Long.valueOf(schemaId)),
    Restrictions.eq(STATUS_PROPERTY, UpdateStatus.INACTIVE)));
  configuration = findOneByCriteria(criteria);
 }
 if (LOG.isTraceEnabled()) {
  LOG.trace("[{},{}] Search result: {}.", schemaId, groupId, configuration);
 } else {
  LOG.debug("[{},{}] Search result: {}.", schemaId, groupId, configuration != null);
 }
 return configuration;
}

.createAlias("student", "s")
.createAlias("course", "c")
.add( Restrictions.isNotEmpty("s.enrolments") )
.setCacheable(true)
.setReadOnly( true )
.list();
.createAlias("student", "s")
.createAlias("course", "c")
.setReadOnly( true )
.add( Restrictions.isNotEmpty("s.enrolments") )
.setCacheable(true)
.setReadOnly( true )
.list();
.createAlias("student", "s")
.createAlias("course", "c")
.add( Restrictions.isNotEmpty("s.enrolments") )
.setCacheable(true)
.list();

@Override
public Configuration findLatestDeprecated(String schemaId, String groupId) {
 Configuration configuration = null;
 LOG.debug("Searching latest deprecated configurations by configuration schema id [{}] "
     + "and group id [{}] ",
   schemaId, groupId);
 if (isNotBlank(schemaId) && isNotBlank(groupId)) {
  Criteria criteria = getCriteria();
  criteria.createAlias(CONFIGURATION_SCHEMA_PROPERTY, CONFIGURATION_SCHEMA_ALIAS);
  criteria.createAlias(ENDPOINT_GROUP_PROPERTY, ENDPOINT_GROUP_ALIAS);
  criteria.add(Restrictions.and(
    Restrictions.eq(ENDPOINT_GROUP_REFERENCE, Long.valueOf(groupId)),
    Restrictions.eq(CONFIGURATION_SCHEMA_REFERENCE, Long.valueOf(schemaId)),
    Restrictions.eq(STATUS_PROPERTY, UpdateStatus.DEPRECATED)));
  criteria.addOrder(Order.desc(SEQUENCE_NUMBER_PROPERTY)).setMaxResults(FIRST);
  configuration = findOneByCriteria(criteria);
 }
 if (LOG.isTraceEnabled()) {
  LOG.trace("[{},{}] Search result: {}.", schemaId, groupId, configuration);
 } else {
  LOG.debug("[{},{}] Search result: {}.", schemaId, groupId, configuration != null);
 }
 return configuration;
}

@Override
public boolean validateName(String tenantId, String ecfId, String name) {
 LOG.debug("Validating by tenant id [{}], ecf id [{}], name [{}]", tenantId, ecfId, name);
 Criteria criteria = getCriteria();
 criteria.createAlias(TENANT_PROPERTY, TENANT_ALIAS);
 criteria.add(Restrictions.and(
   Restrictions.eq(TENANT_REFERENCE, Long.valueOf(tenantId)),
   Restrictions.eq(NAME_PROPERTY, name)));
 if (isNotBlank(ecfId)) {
  criteria = criteria.add(Restrictions.ne(ID_PROPERTY, Long.valueOf(ecfId)));
 }
 List<EventClassFamily> eventClassFamilies = findListByCriteria(criteria);
 boolean result = eventClassFamilies == null || eventClassFamilies.isEmpty();
 LOG.debug("[{},{},{}] Validating result: {}", tenantId, ecfId, name, result);
 return result;
}

@Override
public CtlSchema findLatestByMetaInfoId(String metaInfoId) {
 CtlSchema latestSchema = null;
 LOG.debug("Searching latest version of ctl schema by meta info id [{}]",
   metaInfoId);
 if (isNotBlank(metaInfoId)) {
  Criteria criteria = getCriteria()
    .createAlias(CTL_SCHEMA_META_INFO_PROPERTY, CTL_SCHEMA_META_INFO_ALIAS)
    .add(Restrictions.eq(CTL_SCHEMA_META_INFO_ALIAS_ID, Long.valueOf(metaInfoId)))
    .addOrder(Order.desc(CTL_SCHEMA_VERSION))
    .setMaxResults(FIRST);
  latestSchema = findOneByCriteria(criteria);
 }
 if (LOG.isTraceEnabled()) {
  LOG.trace("[{}] Search result: [{}].", metaInfoId, latestSchema);
 } else {
  LOG.debug("[{}] Search result: [{}].", metaInfoId, latestSchema != null);
 }
 return latestSchema;
}

Javadoc

Join an association, assigning an alias to the joined association.

Functionally equivalent to #createAlias(String,String,JoinType) using JoinType#INNER_JOIN for the joinType.

Popular methods of Criteria

list
Get the results.
add
Add a Criterion to constrain the results to be retrieved.
uniqueResult
Convenience method to return a single instance that matches the query, or null if the query returns
addOrder
Add an Order to the result set.
setProjection
Used to specify that the query results will be a projection (scalar in nature). Implicitly specifies
setMaxResults
Set a limit upon the number of objects to be retrieved.
setFirstResult
Set the first result to be retrieved.
setResultTransformer
Set a strategy for handling the query results. This determines the "shape" of the query result.
createCriteria
Create a new Criteria, "rooted" at the associated entity, using the specified join type.
setFetchMode
Specify an association fetching strategy for an association or a collection of values.
setCacheable
Enable caching of this query result, provided query caching is enabled for the underlying session fa
setFetchSize
Set a fetch size for the underlying JDBC query.

Popular in Java

Reading from database using SQL prepared statement
notifyDataSetChanged (ArrayAdapter)
putExtra (Intent)
onRequestPermissionsResult (Fragment)
EOFException (java.io)
Thrown when a program encounters the end of a file or stream during an input operation.
FileReader (java.io)
A specialized Reader that reads from a file in the file system. All read requests made by calling me
Timer (java.util)
Timers schedule one-shot or recurring TimerTask for execution. Prefer java.util.concurrent.Scheduled
Vector (java.util)
Vector is an implementation of List, backed by an array and synchronized. All optional operations in
AtomicInteger (java.util.concurrent.atomic)
An int value that may be updated atomically. See the java.util.concurrent.atomic package specificati
JComboBox (javax.swing)
From CI to AI: The AI layer in your organization

How to use createAliasmethodin org.hibernate.Criteria

Best Java code snippets using org.hibernate.Criteria.createAlias (Showing top 20 results out of 585)

Refine search

How to use
createAlias
method
in
org.hibernate.Criteria