Example usage for org.hibernate.type StandardBasicTypes TIMESTAMP

List of usage examples for org.hibernate.type StandardBasicTypes TIMESTAMP

  1. HOME
  2. Java
  3. org.hibernate
  4. org.hibernate.type.*
  5. StandardBasicTypes
  6. TIMESTAMP

Introduction

In this page you can find the example usage for org.hibernate.type StandardBasicTypes TIMESTAMP.

Prototype

TimestampType TIMESTAMP

To view the source code for org.hibernate.type StandardBasicTypes TIMESTAMP.

Click Source Link

Document

The standard Hibernate type for mapping java.util.Date ( java.sql.Timestamp ) to JDBC java.sql.Types#TIMESTAMP TIMESTAMP .

Usage

From source file:edu.psu.iam.cpr.core.database.tables.PersonUseridIapTable.java

License:Apache License

/**
 * Retrieve all active PSU IAPS for a userid.
 * @param db An active database handle//from www  .  j  a va  2 s.c  o m
 * @param personId contains the person_id
 * @param userid The userid to query
 * 
 * @return A list of IAPs
 * @throws CprException 
 */
public IAPReturn[] getPSUIAP(final Database db, final long personId, final String userid) throws CprException {

    boolean useridValid = false;
    final Session session = db.getSession();
    useridValid = db.isValidUserid(personId, userid);

    if (!useridValid) {
        throw new CprException(ReturnType.INVALID_PARAMETERS_EXCEPTION, USERID_ARG);
    }

    final List<IAPReturn> results = new ArrayList<IAPReturn>();
    final StringBuilder sb = new StringBuilder(BUFFER_SIZE);
    sb.append("SELECT iap.iap, ");
    sb.append("person_userid_iap.start_date, ");
    sb.append("person_userid_iap.end_date, ");
    sb.append("person_userid_iap.last_update_by, ");
    sb.append("person_userid_iap.last_update_on, ");
    sb.append("person_userid_iap.created_by, ");
    sb.append("person_userid_iap.created_on ");
    sb.append("FROM {h-schema}iap ");
    sb.append("LEFT JOIN {h-schema}person_userid_iap ON iap.iap_key = person_userid_iap.iap_key ");
    sb.append("WHERE person_userid_iap.person_id = :person_id_in ");
    sb.append("AND person_userid_iap.userid=:userid_in ");

    // If we are not returning all records, we need to just return the active ones.
    if (!isReturnHistoryFlag()) {
        sb.append("AND person_userid_iap.end_date IS NULL ");
    }
    sb.append("ORDER BY iap.iap_key ASC, person_userid_iap.start_date ASC ");
    final SQLQuery query = session.createSQLQuery(sb.toString());
    query.setParameter("person_id_in", personId);

    query.setParameter("userid_in", userid);
    query.addScalar("iap", StandardBasicTypes.STRING);
    query.addScalar("start_date", StandardBasicTypes.TIMESTAMP);
    query.addScalar("end_date", StandardBasicTypes.TIMESTAMP);
    query.addScalar("last_update_by", StandardBasicTypes.STRING);
    query.addScalar("last_update_on", StandardBasicTypes.TIMESTAMP);
    query.addScalar("created_by", StandardBasicTypes.STRING);
    query.addScalar("created_on", StandardBasicTypes.TIMESTAMP);

    for (final Iterator<?> it = query.list().iterator(); it.hasNext();) {
        Object[] res = (Object[]) it.next();
        IAPReturn anIAP = new IAPReturn();
        anIAP.setIap((String) res[IAP]);
        anIAP.setStartDate(Utility.formatDateToISO8601((Date) res[START_DATE]));
        anIAP.setEndDate(Utility.formatDateToISO8601((Date) res[END_DATE]));
        anIAP.setLastUpdateBy((String) res[LAST_UPDATE_BY]);
        anIAP.setLastUpdateOn(Utility.formatDateToISO8601((Date) res[LAST_UPDATE_ON]));
        anIAP.setCreatedBy((String) res[CREATED_BY]);
        anIAP.setCreatedOn(Utility.formatDateToISO8601((Date) res[CREATED_ON]));
        results.add(anIAP);
    }

    return results.toArray(new IAPReturn[results.size()]);
}

From source file:edu.psu.iam.cpr.core.database.tables.PhonesTable.java

License:Apache License

/**
 * This routine will obtain a list of phone numbers for a person id
 * @param db /*from w w w . jav a2  s.  c o m*/
 * @param personId contains the personID
 * @return list of phone numbers
 */
public PhoneReturn[] getPhones(final Database db, final long personId) {

    final List<PhoneReturn> results = new ArrayList<PhoneReturn>();

    final Session session = db.getSession();
    final StringBuilder sb = new StringBuilder(BUFFER_SIZE);
    sb.append(
            "SELECT phone_key, data_type_key, group_id, primary_flag, phone_number, extension, international_number_flag,  ");
    sb.append("start_date, ");
    sb.append("end_date, ");
    sb.append("last_update_by, ");
    sb.append("last_update_on, ");
    sb.append("created_by, ");
    sb.append("created_on ");
    sb.append("FROM {h-schema}phones ");
    sb.append("WHERE person_id = :person_id_in ");

    if (getPhoneType() != null) {
        sb.append("AND data_type_key = :data_type_key_in ");
    }

    if (!isReturnHistoryFlag()) {
        sb.append("AND end_date IS NULL");
    }

    if (getPhoneKey() > 0L) {
        sb.append("AND phone_key = :phone_key ");
    }

    sb.append(" ORDER BY data_type_key ASC, start_date ASC ");

    final SQLQuery query = session.createSQLQuery(sb.toString());
    query.setParameter("person_id_in", personId);

    if (getPhoneType() != null) {
        query.setParameter("data_type_key_in", getPhoneType().index());
    }

    if (getPhoneKey() > 0L) {
        query.setParameter(PHONE_KEY_STRING, getPhoneKey());
    }

    query.addScalar(PHONE_KEY_STRING, StandardBasicTypes.LONG);
    query.addScalar(DATA_TYPE_KEY_STRING, StandardBasicTypes.LONG);
    query.addScalar(GROUP_ID_STRING, StandardBasicTypes.LONG);
    query.addScalar("primary_flag", StandardBasicTypes.STRING);
    query.addScalar("phone_number", StandardBasicTypes.STRING);
    query.addScalar("extension", StandardBasicTypes.STRING);
    query.addScalar("international_number_flag", StandardBasicTypes.STRING);
    query.addScalar("start_date", StandardBasicTypes.TIMESTAMP);
    query.addScalar("end_date", StandardBasicTypes.TIMESTAMP);
    query.addScalar("last_update_by", StandardBasicTypes.STRING);
    query.addScalar("last_update_on", StandardBasicTypes.TIMESTAMP);
    query.addScalar("created_by", StandardBasicTypes.STRING);
    query.addScalar("created_on", StandardBasicTypes.TIMESTAMP);

    for (final Iterator<?> it = query.list().iterator(); it.hasNext();) {
        Object[] res = (Object[]) it.next();
        PhoneReturn aPhone = new PhoneReturn();
        aPhone.setPhoneKey(((Long) res[PHONE_KEY]).toString());
        aPhone.setPhoneType(PhoneType.get((Long) res[PHONE_TYPE]).toString());
        aPhone.setGroupId((Long) res[GROUP_ID]);
        aPhone.setPrimaryFlag((String) res[PRIMARY_FLAG]);
        aPhone.setPhoneNumber((String) res[PHONE_NUMBER]);
        aPhone.setExtension((String) res[EXTENSION]);
        aPhone.setInternationalNumber((String) res[INTERNATIONAL_NUMBER]);
        aPhone.setStartDate(Utility.formatDateToISO8601((Date) res[START_DATE]));
        aPhone.setEndDate(Utility.formatDateToISO8601((Date) res[END_DATE]));
        aPhone.setLastUpdateBy((String) res[LAST_UPDATE_BY]);
        aPhone.setLastUpdateOn(Utility.formatDateToISO8601((Date) res[LAST_UPDATE_ON]));
        aPhone.setCreatedBy((String) res[CREATED_BY]);
        aPhone.setCreatedOn(Utility.formatDateToISO8601((Date) res[CREATED_ON]));
        results.add(aPhone);
    }

    return results.toArray(new PhoneReturn[results.size()]);
}

From source file:edu.psu.iam.cpr.core.database.tables.PsuIdTable.java

License:Apache License

/**
 * This routine is used to obtain the PSU ID for a specific person.
 * @param db contains the open database connection.
 * @param personId contains the person identifier used to retrieve the PSU ID for.
 * @return will return a PsuIdReturn object if success.
 *//*from  ww w .j  ava 2s.  co m*/
public PsuIdReturn[] getPsuIdForPersonId(final Database db, final long personId) {

    final Session session = db.getSession();
    final List<PsuIdReturn> results = new ArrayList<PsuIdReturn>();
    final StringBuilder sb = new StringBuilder(BUFFER_SIZE);

    sb.append("SELECT psu_id, ");
    sb.append("start_date, ");
    sb.append("end_date, ");
    sb.append("last_update_by, ");
    sb.append("last_update_on, ");
    sb.append("created_by, ");
    sb.append("created_on ");
    sb.append("FROM {h-schema}psu_id WHERE person_id=:person_id ");

    // If we are not returning all records, we need to just return the active ones.
    if (!isReturnHistoryFlag()) {
        sb.append("AND end_date IS NULL ");
    }
    sb.append("ORDER BY start_date ASC ");

    final SQLQuery query = session.createSQLQuery(sb.toString());
    query.setParameter("person_id", personId);
    query.addScalar("psu_id", StandardBasicTypes.STRING);
    query.addScalar("start_date", StandardBasicTypes.TIMESTAMP);
    query.addScalar("end_date", StandardBasicTypes.TIMESTAMP);
    query.addScalar("last_update_by", StandardBasicTypes.STRING);
    query.addScalar("last_update_on", StandardBasicTypes.TIMESTAMP);
    query.addScalar("created_by", StandardBasicTypes.STRING);
    query.addScalar("created_on", StandardBasicTypes.TIMESTAMP);

    for (final Iterator<?> it = query.list().iterator(); it.hasNext();) {
        Object[] res = (Object[]) it.next();
        results.add(new PsuIdReturn((String) res[PSU_ID], Utility.formatDateToISO8601((Date) res[START_DATE]),
                Utility.formatDateToISO8601((Date) res[END_DATE]), (String) res[LAST_UPDATE_BY],
                Utility.formatDateToISO8601((Date) res[LAST_UPDATE_ON]), (String) res[CREATED_BY],
                Utility.formatDateToISO8601((Date) res[CREATED_ON])));
    }
    return results.toArray(new PsuIdReturn[results.size()]);
}

From source file:edu.psu.iam.cpr.core.database.tables.UserCommentTable.java

License:Apache License

/**
 * Obtain user comments.//from   w  w  w.  j  av a 2s  .c o  m
 * @param db
 * @param userId contains the user id of person.
 * @return an array of user comments.
 */
public UserCommentReturn[] getUserComments(final Database db, final String userId) {

    final List<UserCommentReturn> results = new ArrayList<UserCommentReturn>();

    final Session session = db.getSession();

    // Build the query string.
    final StringBuilder sb = new StringBuilder(BUFFER_SIZE);
    sb.append("SELECT user_comment_key, data_type_key, comments, ");
    sb.append("start_date, ");
    sb.append("end_date, ");
    sb.append("last_update_by, ");
    sb.append("last_update_on, ");
    sb.append("created_by ");
    sb.append("FROM {h-schema}user_comments ");
    sb.append("WHERE userid = :userid_in ");

    if (getUserCommentType() != null) {
        sb.append("AND data_type_key = :data_type_key_in ");
    }

    // If we are not returning all records, we need to just return the active ones.
    if (!isReturnHistoryFlag()) {
        sb.append("AND end_date IS NULL ");
    }

    if (getCommentKey() > 0L) {
        sb.append("AND user_comment_key = :user_comment_key ");
    }

    sb.append("ORDER BY data_type_key ASC, start_date ASC ");

    // Init the hibernate query.
    final SQLQuery query = session.createSQLQuery(sb.toString());
    query.setParameter("userid_in", userId);

    if (getUserCommentType() != null) {
        query.setParameter("data_type_key_in", getUserCommentType().index());
    }

    if (getCommentKey() > 0L) {
        query.setParameter("user_comment_key", getCommentKey());
    }

    query.addScalar("user_comment_key", StandardBasicTypes.LONG);
    query.addScalar("data_type_key", StandardBasicTypes.LONG);
    query.addScalar("comments", StandardBasicTypes.STRING);
    query.addScalar("start_date", StandardBasicTypes.TIMESTAMP);
    query.addScalar("end_date", StandardBasicTypes.TIMESTAMP);
    query.addScalar("last_update_by", StandardBasicTypes.STRING);
    query.addScalar("last_update_on", StandardBasicTypes.TIMESTAMP);
    query.addScalar("created_by", StandardBasicTypes.STRING);

    // Perform the query.
    final Iterator<?> it = query.list().iterator();

    // Process the results.
    while (it.hasNext()) {
        Object[] res = (Object[]) it.next();
        UserCommentReturn ucr = new UserCommentReturn();
        ucr.setCommentKey(((Long) res[COMMENT_KEY]).toString());
        ucr.setUserCommentType(UserCommentType.get((Long) res[USER_COMMENT_TYPE]).toString());
        ucr.setComment((String) res[COMMENT]);
        ucr.setCommentDateString(Utility.formatDateToISO8601((Date) res[COMMENT_DATE_STRING]));
        ucr.setEndDate(Utility.formatDateToISO8601((Date) res[END_DATE]));
        ucr.setLastUpdatedBy((String) res[LAST_UPDATE_BY]);
        ucr.setLastUpdateOn(Utility.formatDateToISO8601((Date) res[LAST_UPDATE_ON]));
        ucr.setCommenter((String) res[COMMENTER]);
        results.add(ucr);
    }

    return results.toArray(new UserCommentReturn[results.size()]);
}

From source file:edu.psu.iam.cpr.core.database.tables.UseridTable.java

License:Apache License

/**
 * This routine will obtain a list of userids for a person id.
 * @param db contains an open database connection.
 * @param personId contains the person id.
 * @return an array of userids./* www .  j a  v  a2  s .c  om*/
 */
public UseridReturn[] getUseridsForPersonId(final Database db, final long personId) {

    final Session session = db.getSession();
    final List<UseridReturn> results = new ArrayList<UseridReturn>();

    final StringBuilder sb = new StringBuilder(BUFFER_SIZE);
    sb.append("SELECT userid, primary_flag, ");
    sb.append("start_date, ");
    sb.append("end_date, ");
    sb.append("last_update_by, ");
    sb.append("last_update_on, ");
    sb.append("created_by, ");
    sb.append("created_on ");
    sb.append("FROM {h-schema}userid ");
    sb.append("WHERE person_id = :person_id_in ");
    if (!isReturnHistoryFlag()) {
        sb.append("AND end_date IS NULL ");
    }
    if (getUserid() != null) {
        sb.append("AND userid = :userid ");
    }
    sb.append("ORDER BY start_date");

    final SQLQuery query = session.createSQLQuery(sb.toString());

    query.setParameter("person_id_in", personId);

    if (getUserid() != null) {
        query.setParameter("userid", getUserid());
    }

    query.addScalar("userid", StandardBasicTypes.STRING);
    query.addScalar("primary_flag", StandardBasicTypes.STRING);
    query.addScalar("start_date", StandardBasicTypes.TIMESTAMP);
    query.addScalar("end_date", StandardBasicTypes.TIMESTAMP);
    query.addScalar("last_update_by", StandardBasicTypes.STRING);
    query.addScalar("last_update_on", StandardBasicTypes.TIMESTAMP);
    query.addScalar("created_by", StandardBasicTypes.STRING);
    query.addScalar("created_on", StandardBasicTypes.TIMESTAMP);

    for (final Iterator<?> it = query.list().iterator(); it.hasNext();) {
        Object[] res = (Object[]) it.next();
        results.add(new UseridReturn((String) res[USERID], (String) res[PRIMARY_FLAG],
                Utility.formatDateToISO8601((Date) res[START_DATE]),
                Utility.formatDateToISO8601((Date) res[END_DATE]), (String) res[LAST_UPDATE_BY],
                Utility.formatDateToISO8601((Date) res[LAST_UPDATE_ON]), (String) res[CREATED_BY],
                Utility.formatDateToISO8601((Date) res[CREATED_ON])));
    }

    return results.toArray(new UseridReturn[results.size()]);
}

From source file:edu.utn.frba.grupo5303.serverenviolibre.config.LocalDateTimeUserType.java

@Override
public Object nullSafeGet(ResultSet rs, String[] strings, SessionImplementor si, Object o)
        throws HibernateException, SQLException {
    Object timestamp = StandardBasicTypes.TIMESTAMP.nullSafeGet(rs, strings, si, o);
    if (timestamp == null) {
        return null;
    }//from w  w  w  . j  av a 2s .co  m
    Date ts = (Date) timestamp;
    Instant instant = Instant.ofEpochMilli(ts.getTime());
    return LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
}

From source file:edu.utn.frba.grupo5303.serverenviolibre.config.LocalDateTimeUserType.java

@Override
public void nullSafeSet(PreparedStatement ps, Object o, int i, SessionImplementor si)
        throws HibernateException, SQLException {
    if (o == null) {
        StandardBasicTypes.TIMESTAMP.nullSafeSet(ps, null, i, si);
    } else {//from  w  w  w  . ja v a  2  s  . co  m
        LocalDateTime ldt = ((LocalDateTime) o);
        Instant instant = ldt.atZone(ZoneId.systemDefault()).toInstant();
        Date timestamp = Date.from(instant);
        StandardBasicTypes.TIMESTAMP.nullSafeSet(ps, timestamp, i, si);
    }
}

From source file:fr.gael.dhus.olingo.v1.SQLVisitor.java

License:Open Source License

@Override
public Object visitMethod(MethodExpression method_expression, MethodOperator method, List<Object> parameters) {
    Criterion criterion;/*  w  w w  . java 2s  . c  om*/
    switch (method) {
    // String functions
    case CONCAT: {
        criterion = Restrictions.sqlRestriction("CONCAT(?,?)",
                new Object[] { parameters.get(0), parameters.get(1) },
                new Type[] { StandardBasicTypes.STRING, StandardBasicTypes.STRING });
        break;
    }
    case INDEXOF: {
        criterion = Restrictions.sqlRestriction("LOCATE(?,?)",
                new Object[] { parameters.get(0), parameters.get(1) },
                new Type[] { StandardBasicTypes.STRING, StandardBasicTypes.STRING });
        break;
    }
    case LENGTH: {
        criterion = Restrictions.sqlRestriction("LENGTH(?)", parameters.get(0), StandardBasicTypes.STRING);
        break;
    }
    case SUBSTRING: {
        criterion = Restrictions.sqlRestriction("SUBSTR(?,?)",
                new Object[] { parameters.get(0), parameters.get(1) },
                new Type[] { StandardBasicTypes.STRING, StandardBasicTypes.STRING });
        break;
    }
    case TOUPPER: {
        criterion = Restrictions.sqlRestriction("UPPER(?)", parameters.get(0), StandardBasicTypes.STRING);
        break;
    }
    case TOLOWER: {
        criterion = Restrictions.sqlRestriction("LOWER(?)", parameters.get(0), StandardBasicTypes.STRING);
        break;
    }
    case TRIM: {
        criterion = Restrictions.sqlRestriction("TRIM(?)", parameters.get(0), StandardBasicTypes.STRING);
        break;
    }
    case ENDSWITH:
    case STARTSWITH: {
        criterion = getCriterionFunction(method, parameters.get(0), parameters.get(1));
        break;
    }
    case SUBSTRINGOF: {
        criterion = getCriterionFunction(method, parameters.get(1), parameters.get(0));
        break;
    }

    // Date functions
    case DAY: {
        criterion = Restrictions.sqlRestriction("DAYOFMONTH(?)", parameters.get(0),
                StandardBasicTypes.TIMESTAMP);
        break;
    }
    case HOUR: {
        criterion = Restrictions.sqlRestriction("HOUR(?)", parameters.get(0), StandardBasicTypes.TIMESTAMP);
        break;
    }
    case MINUTE: {
        criterion = Restrictions.sqlRestriction("MINUTE(?)", parameters.get(0), StandardBasicTypes.TIMESTAMP);
        break;
    }
    case MONTH: {
        criterion = Restrictions.sqlRestriction("MONTH(?)", parameters.get(0), StandardBasicTypes.TIMESTAMP);
        break;
    }
    case SECOND: {
        criterion = Restrictions.sqlRestriction("SECOND(?)", parameters.get(0), StandardBasicTypes.TIMESTAMP);
        break;
    }
    case YEAR: {
        criterion = Restrictions.sqlRestriction("YEAR(?)", parameters.get(0), StandardBasicTypes.TIMESTAMP);
        break;
    }

    // Math functions
    case CEILING: {
        criterion = Restrictions.sqlRestriction("CEILING(?)", parameters.get(0), StandardBasicTypes.DOUBLE);
        break;
    }
    case FLOOR: {
        criterion = Restrictions.sqlRestriction("FLOOR (?)", parameters.get(0), StandardBasicTypes.DOUBLE);
        break;
    }
    case ROUND: {
        criterion = Restrictions.sqlRestriction("ROUND(?)", parameters.get(0), StandardBasicTypes.DOUBLE);
        break;
    }

    default:
        throw new UnsupportedOperationException("Unsupported method: " + method.toUriLiteral());
    }

    return criterion;
}

From source file:kr.debop4j.data.hibernate.usertype.JodaDateTimeUserType.java

License:Apache License

@Override
public void nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)
        throws HibernateException, SQLException {
    if (value == null) {
        StandardBasicTypes.TIMESTAMP.nullSafeSet(st, null, index, session);
    } else {//from  w  w  w  .j av a  2  s .c  o  m
        StandardBasicTypes.TIMESTAMP.nullSafeSet(st, asDateTime(value).toDate(), index, session);
    }
}

From source file:kr.debop4j.data.hibernate.usertype.TimeRangeUserType.java

License:Apache License

@Override
public Object nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)
        throws HibernateException, SQLException {

    Date start = (Date) StandardBasicTypes.TIMESTAMP.nullSafeGet(rs, names[0], session, owner);
    Date end = (Date) StandardBasicTypes.TIMESTAMP.nullSafeGet(rs, names[1], session, owner);

    return new DateTimeRange(new DateTime(start), new DateTime(end));
}