Java tutorial
/** * Copyright (c) 2000-present Liferay, Inc. All rights reserved. * * This library is free software; you can redistribute it and/or modify it under * the terms of the GNU Lesser General Public License as published by the Free * Software Foundation; either version 2.1 of the License, or (at your option) * any later version. * * This library is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more * details. */ package com.bemis.portal.shipment.service.persistence.impl; import aQute.bnd.annotation.ProviderType; import com.bemis.portal.shipment.exception.NoSuchShipmentException; import com.bemis.portal.shipment.model.Shipment; import com.bemis.portal.shipment.model.impl.ShipmentImpl; import com.bemis.portal.shipment.model.impl.ShipmentModelImpl; import com.bemis.portal.shipment.service.persistence.ShipmentPersistence; import com.liferay.portal.kernel.dao.orm.EntityCache; import com.liferay.portal.kernel.dao.orm.FinderCache; import com.liferay.portal.kernel.dao.orm.FinderPath; import com.liferay.portal.kernel.dao.orm.Query; import com.liferay.portal.kernel.dao.orm.QueryPos; import com.liferay.portal.kernel.dao.orm.QueryUtil; import com.liferay.portal.kernel.dao.orm.Session; import com.liferay.portal.kernel.log.Log; import com.liferay.portal.kernel.log.LogFactoryUtil; import com.liferay.portal.kernel.service.ServiceContext; import com.liferay.portal.kernel.service.ServiceContextThreadLocal; import com.liferay.portal.kernel.service.persistence.CompanyProvider; import com.liferay.portal.kernel.service.persistence.CompanyProviderWrapper; import com.liferay.portal.kernel.service.persistence.impl.BasePersistenceImpl; import com.liferay.portal.kernel.util.ArrayUtil; import com.liferay.portal.kernel.util.OrderByComparator; import com.liferay.portal.kernel.util.StringBundler; import com.liferay.portal.kernel.util.StringPool; import com.liferay.portal.kernel.util.StringUtil; import com.liferay.portal.spring.extender.service.ServiceReference; import java.io.Serializable; import java.util.Arrays; import java.util.Collections; import java.util.Date; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Objects; import java.util.Set; /** * The persistence implementation for the shipment service. * * <p> * Caching information and settings can be found in <code>portal.properties</code> * </p> * * @author Thuong Dinh * @see ShipmentPersistence * @see com.bemis.portal.shipment.service.persistence.ShipmentUtil * @generated */ @ProviderType public class ShipmentPersistenceImpl extends BasePersistenceImpl<Shipment> implements ShipmentPersistence { /* * NOTE FOR DEVELOPERS: * * Never modify or reference this class directly. Always use {@link ShipmentUtil} to access the shipment persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. */ public static final String FINDER_CLASS_NAME_ENTITY = ShipmentImpl.class.getName(); public static final String FINDER_CLASS_NAME_LIST_WITH_PAGINATION = FINDER_CLASS_NAME_ENTITY + ".List1"; public static final String FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION = FINDER_CLASS_NAME_ENTITY + ".List2"; public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_ALL = new FinderPath( ShipmentModelImpl.ENTITY_CACHE_ENABLED, ShipmentModelImpl.FINDER_CACHE_ENABLED, ShipmentImpl.class, FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findAll", new String[0]); public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL = new FinderPath( ShipmentModelImpl.ENTITY_CACHE_ENABLED, ShipmentModelImpl.FINDER_CACHE_ENABLED, ShipmentImpl.class, FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findAll", new String[0]); public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(ShipmentModelImpl.ENTITY_CACHE_ENABLED, ShipmentModelImpl.FINDER_CACHE_ENABLED, Long.class, FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countAll", new String[0]); public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_SHIPTOID = new FinderPath( ShipmentModelImpl.ENTITY_CACHE_ENABLED, ShipmentModelImpl.FINDER_CACHE_ENABLED, ShipmentImpl.class, FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByShipToId", new String[] { String.class.getName(), Integer.class.getName(), Integer.class.getName(), OrderByComparator.class.getName() }); public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_SHIPTOID = new FinderPath( ShipmentModelImpl.ENTITY_CACHE_ENABLED, ShipmentModelImpl.FINDER_CACHE_ENABLED, ShipmentImpl.class, FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByShipToId", new String[] { String.class.getName() }, ShipmentModelImpl.SHIPTOID_COLUMN_BITMASK | ShipmentModelImpl.SHIPMENTDATE_COLUMN_BITMASK); public static final FinderPath FINDER_PATH_COUNT_BY_SHIPTOID = new FinderPath( ShipmentModelImpl.ENTITY_CACHE_ENABLED, ShipmentModelImpl.FINDER_CACHE_ENABLED, Long.class, FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByShipToId", new String[] { String.class.getName() }); /** * Returns all the shipments where shipToId = ?. * * @param shipToId the ship to ID * @return the matching shipments */ @Override public List<Shipment> findByShipToId(String shipToId) { return findByShipToId(shipToId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null); } /** * Returns a range of all the shipments where shipToId = ?. * * <p> * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ShipmentModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. * </p> * * @param shipToId the ship to ID * @param start the lower bound of the range of shipments * @param end the upper bound of the range of shipments (not inclusive) * @return the range of matching shipments */ @Override public List<Shipment> findByShipToId(String shipToId, int start, int end) { return findByShipToId(shipToId, start, end, null); } /** * Returns an ordered range of all the shipments where shipToId = ?. * * <p> * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ShipmentModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. * </p> * * @param shipToId the ship to ID * @param start the lower bound of the range of shipments * @param end the upper bound of the range of shipments (not inclusive) * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) * @return the ordered range of matching shipments */ @Override public List<Shipment> findByShipToId(String shipToId, int start, int end, OrderByComparator<Shipment> orderByComparator) { return findByShipToId(shipToId, start, end, orderByComparator, true); } /** * Returns an ordered range of all the shipments where shipToId = ?. * * <p> * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ShipmentModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. * </p> * * @param shipToId the ship to ID * @param start the lower bound of the range of shipments * @param end the upper bound of the range of shipments (not inclusive) * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) * @param retrieveFromCache whether to retrieve from the finder cache * @return the ordered range of matching shipments */ @Override public List<Shipment> findByShipToId(String shipToId, int start, int end, OrderByComparator<Shipment> orderByComparator, boolean retrieveFromCache) { boolean pagination = true; FinderPath finderPath = null; Object[] finderArgs = null; if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) && (orderByComparator == null)) { pagination = false; finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_SHIPTOID; finderArgs = new Object[] { shipToId }; } else { finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_SHIPTOID; finderArgs = new Object[] { shipToId, start, end, orderByComparator }; } List<Shipment> list = null; if (retrieveFromCache) { list = (List<Shipment>) finderCache.getResult(finderPath, finderArgs, this); if ((list != null) && !list.isEmpty()) { for (Shipment shipment : list) { if (!Objects.equals(shipToId, shipment.getShipToId())) { list = null; break; } } } } if (list == null) { StringBundler query = null; if (orderByComparator != null) { query = new StringBundler(3 + (orderByComparator.getOrderByFields().length * 2)); } else { query = new StringBundler(3); } query.append(_SQL_SELECT_SHIPMENT_WHERE); boolean bindShipToId = false; if (shipToId == null) { query.append(_FINDER_COLUMN_SHIPTOID_SHIPTOID_1); } else if (shipToId.equals(StringPool.BLANK)) { query.append(_FINDER_COLUMN_SHIPTOID_SHIPTOID_3); } else { bindShipToId = true; query.append(_FINDER_COLUMN_SHIPTOID_SHIPTOID_2); } if (orderByComparator != null) { appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, orderByComparator); } else if (pagination) { query.append(ShipmentModelImpl.ORDER_BY_JPQL); } String sql = query.toString(); Session session = null; try { session = openSession(); Query q = session.createQuery(sql); QueryPos qPos = QueryPos.getInstance(q); if (bindShipToId) { qPos.add(shipToId); } if (!pagination) { list = (List<Shipment>) QueryUtil.list(q, getDialect(), start, end, false); Collections.sort(list); list = Collections.unmodifiableList(list); } else { list = (List<Shipment>) QueryUtil.list(q, getDialect(), start, end); } cacheResult(list); finderCache.putResult(finderPath, finderArgs, list); } catch (Exception e) { finderCache.removeResult(finderPath, finderArgs); throw processException(e); } finally { closeSession(session); } } return list; } /** * Returns the first shipment in the ordered set where shipToId = ?. * * @param shipToId the ship to ID * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) * @return the first matching shipment * @throws NoSuchShipmentException if a matching shipment could not be found */ @Override public Shipment findByShipToId_First(String shipToId, OrderByComparator<Shipment> orderByComparator) throws NoSuchShipmentException { Shipment shipment = fetchByShipToId_First(shipToId, orderByComparator); if (shipment != null) { return shipment; } StringBundler msg = new StringBundler(4); msg.append(_NO_SUCH_ENTITY_WITH_KEY); msg.append("shipToId="); msg.append(shipToId); msg.append(StringPool.CLOSE_CURLY_BRACE); throw new NoSuchShipmentException(msg.toString()); } /** * Returns the first shipment in the ordered set where shipToId = ?. * * @param shipToId the ship to ID * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) * @return the first matching shipment, or <code>null</code> if a matching shipment could not be found */ @Override public Shipment fetchByShipToId_First(String shipToId, OrderByComparator<Shipment> orderByComparator) { List<Shipment> list = findByShipToId(shipToId, 0, 1, orderByComparator); if (!list.isEmpty()) { return list.get(0); } return null; } /** * Returns the last shipment in the ordered set where shipToId = ?. * * @param shipToId the ship to ID * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) * @return the last matching shipment * @throws NoSuchShipmentException if a matching shipment could not be found */ @Override public Shipment findByShipToId_Last(String shipToId, OrderByComparator<Shipment> orderByComparator) throws NoSuchShipmentException { Shipment shipment = fetchByShipToId_Last(shipToId, orderByComparator); if (shipment != null) { return shipment; } StringBundler msg = new StringBundler(4); msg.append(_NO_SUCH_ENTITY_WITH_KEY); msg.append("shipToId="); msg.append(shipToId); msg.append(StringPool.CLOSE_CURLY_BRACE); throw new NoSuchShipmentException(msg.toString()); } /** * Returns the last shipment in the ordered set where shipToId = ?. * * @param shipToId the ship to ID * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) * @return the last matching shipment, or <code>null</code> if a matching shipment could not be found */ @Override public Shipment fetchByShipToId_Last(String shipToId, OrderByComparator<Shipment> orderByComparator) { int count = countByShipToId(shipToId); if (count == 0) { return null; } List<Shipment> list = findByShipToId(shipToId, count - 1, count, orderByComparator); if (!list.isEmpty()) { return list.get(0); } return null; } /** * Returns the shipments before and after the current shipment in the ordered set where shipToId = ?. * * @param shipmentId the primary key of the current shipment * @param shipToId the ship to ID * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) * @return the previous, current, and next shipment * @throws NoSuchShipmentException if a shipment with the primary key could not be found */ @Override public Shipment[] findByShipToId_PrevAndNext(long shipmentId, String shipToId, OrderByComparator<Shipment> orderByComparator) throws NoSuchShipmentException { Shipment shipment = findByPrimaryKey(shipmentId); Session session = null; try { session = openSession(); Shipment[] array = new ShipmentImpl[3]; array[0] = getByShipToId_PrevAndNext(session, shipment, shipToId, orderByComparator, true); array[1] = shipment; array[2] = getByShipToId_PrevAndNext(session, shipment, shipToId, orderByComparator, false); return array; } catch (Exception e) { throw processException(e); } finally { closeSession(session); } } protected Shipment getByShipToId_PrevAndNext(Session session, Shipment shipment, String shipToId, OrderByComparator<Shipment> orderByComparator, boolean previous) { StringBundler query = null; if (orderByComparator != null) { query = new StringBundler(4 + (orderByComparator.getOrderByConditionFields().length * 3) + (orderByComparator.getOrderByFields().length * 3)); } else { query = new StringBundler(3); } query.append(_SQL_SELECT_SHIPMENT_WHERE); boolean bindShipToId = false; if (shipToId == null) { query.append(_FINDER_COLUMN_SHIPTOID_SHIPTOID_1); } else if (shipToId.equals(StringPool.BLANK)) { query.append(_FINDER_COLUMN_SHIPTOID_SHIPTOID_3); } else { bindShipToId = true; query.append(_FINDER_COLUMN_SHIPTOID_SHIPTOID_2); } if (orderByComparator != null) { String[] orderByConditionFields = orderByComparator.getOrderByConditionFields(); if (orderByConditionFields.length > 0) { query.append(WHERE_AND); } for (int i = 0; i < orderByConditionFields.length; i++) { query.append(_ORDER_BY_ENTITY_ALIAS); query.append(orderByConditionFields[i]); if ((i + 1) < orderByConditionFields.length) { if (orderByComparator.isAscending() ^ previous) { query.append(WHERE_GREATER_THAN_HAS_NEXT); } else { query.append(WHERE_LESSER_THAN_HAS_NEXT); } } else { if (orderByComparator.isAscending() ^ previous) { query.append(WHERE_GREATER_THAN); } else { query.append(WHERE_LESSER_THAN); } } } query.append(ORDER_BY_CLAUSE); String[] orderByFields = orderByComparator.getOrderByFields(); for (int i = 0; i < orderByFields.length; i++) { query.append(_ORDER_BY_ENTITY_ALIAS); query.append(orderByFields[i]); if ((i + 1) < orderByFields.length) { if (orderByComparator.isAscending() ^ previous) { query.append(ORDER_BY_ASC_HAS_NEXT); } else { query.append(ORDER_BY_DESC_HAS_NEXT); } } else { if (orderByComparator.isAscending() ^ previous) { query.append(ORDER_BY_ASC); } else { query.append(ORDER_BY_DESC); } } } } else { query.append(ShipmentModelImpl.ORDER_BY_JPQL); } String sql = query.toString(); Query q = session.createQuery(sql); q.setFirstResult(0); q.setMaxResults(2); QueryPos qPos = QueryPos.getInstance(q); if (bindShipToId) { qPos.add(shipToId); } if (orderByComparator != null) { Object[] values = orderByComparator.getOrderByConditionValues(shipment); for (Object value : values) { qPos.add(value); } } List<Shipment> list = q.list(); if (list.size() == 2) { return list.get(1); } else { return null; } } /** * Removes all the shipments where shipToId = ? from the database. * * @param shipToId the ship to ID */ @Override public void removeByShipToId(String shipToId) { for (Shipment shipment : findByShipToId(shipToId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) { remove(shipment); } } /** * Returns the number of shipments where shipToId = ?. * * @param shipToId the ship to ID * @return the number of matching shipments */ @Override public int countByShipToId(String shipToId) { FinderPath finderPath = FINDER_PATH_COUNT_BY_SHIPTOID; Object[] finderArgs = new Object[] { shipToId }; Long count = (Long) finderCache.getResult(finderPath, finderArgs, this); if (count == null) { StringBundler query = new StringBundler(2); query.append(_SQL_COUNT_SHIPMENT_WHERE); boolean bindShipToId = false; if (shipToId == null) { query.append(_FINDER_COLUMN_SHIPTOID_SHIPTOID_1); } else if (shipToId.equals(StringPool.BLANK)) { query.append(_FINDER_COLUMN_SHIPTOID_SHIPTOID_3); } else { bindShipToId = true; query.append(_FINDER_COLUMN_SHIPTOID_SHIPTOID_2); } String sql = query.toString(); Session session = null; try { session = openSession(); Query q = session.createQuery(sql); QueryPos qPos = QueryPos.getInstance(q); if (bindShipToId) { qPos.add(shipToId); } count = (Long) q.uniqueResult(); finderCache.putResult(finderPath, finderArgs, count); } catch (Exception e) { finderCache.removeResult(finderPath, finderArgs); throw processException(e); } finally { closeSession(session); } } return count.intValue(); } private static final String _FINDER_COLUMN_SHIPTOID_SHIPTOID_1 = "shipment.shipToId IS NULL"; private static final String _FINDER_COLUMN_SHIPTOID_SHIPTOID_2 = "shipment.shipToId = ?"; private static final String _FINDER_COLUMN_SHIPTOID_SHIPTOID_3 = "(shipment.shipToId IS NULL OR shipment.shipToId = '')"; public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_ORDERID = new FinderPath( ShipmentModelImpl.ENTITY_CACHE_ENABLED, ShipmentModelImpl.FINDER_CACHE_ENABLED, ShipmentImpl.class, FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByOrderId", new String[] { Long.class.getName(), Integer.class.getName(), Integer.class.getName(), OrderByComparator.class.getName() }); public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_ORDERID = new FinderPath( ShipmentModelImpl.ENTITY_CACHE_ENABLED, ShipmentModelImpl.FINDER_CACHE_ENABLED, ShipmentImpl.class, FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByOrderId", new String[] { Long.class.getName() }, ShipmentModelImpl.ORDERID_COLUMN_BITMASK | ShipmentModelImpl.SHIPMENTDATE_COLUMN_BITMASK); public static final FinderPath FINDER_PATH_COUNT_BY_ORDERID = new FinderPath( ShipmentModelImpl.ENTITY_CACHE_ENABLED, ShipmentModelImpl.FINDER_CACHE_ENABLED, Long.class, FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByOrderId", new String[] { Long.class.getName() }); public static final FinderPath FINDER_PATH_WITH_PAGINATION_COUNT_BY_ORDERID = new FinderPath( ShipmentModelImpl.ENTITY_CACHE_ENABLED, ShipmentModelImpl.FINDER_CACHE_ENABLED, Long.class, FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "countByOrderId", new String[] { Long.class.getName() }); /** * Returns all the shipments where orderId = ?. * * @param orderId the order ID * @return the matching shipments */ @Override public List<Shipment> findByOrderId(long orderId) { return findByOrderId(orderId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null); } /** * Returns a range of all the shipments where orderId = ?. * * <p> * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ShipmentModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. * </p> * * @param orderId the order ID * @param start the lower bound of the range of shipments * @param end the upper bound of the range of shipments (not inclusive) * @return the range of matching shipments */ @Override public List<Shipment> findByOrderId(long orderId, int start, int end) { return findByOrderId(orderId, start, end, null); } /** * Returns an ordered range of all the shipments where orderId = ?. * * <p> * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ShipmentModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. * </p> * * @param orderId the order ID * @param start the lower bound of the range of shipments * @param end the upper bound of the range of shipments (not inclusive) * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) * @return the ordered range of matching shipments */ @Override public List<Shipment> findByOrderId(long orderId, int start, int end, OrderByComparator<Shipment> orderByComparator) { return findByOrderId(orderId, start, end, orderByComparator, true); } /** * Returns an ordered range of all the shipments where orderId = ?. * * <p> * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ShipmentModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. * </p> * * @param orderId the order ID * @param start the lower bound of the range of shipments * @param end the upper bound of the range of shipments (not inclusive) * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) * @param retrieveFromCache whether to retrieve from the finder cache * @return the ordered range of matching shipments */ @Override public List<Shipment> findByOrderId(long orderId, int start, int end, OrderByComparator<Shipment> orderByComparator, boolean retrieveFromCache) { boolean pagination = true; FinderPath finderPath = null; Object[] finderArgs = null; if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) && (orderByComparator == null)) { pagination = false; finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_ORDERID; finderArgs = new Object[] { orderId }; } else { finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_ORDERID; finderArgs = new Object[] { orderId, start, end, orderByComparator }; } List<Shipment> list = null; if (retrieveFromCache) { list = (List<Shipment>) finderCache.getResult(finderPath, finderArgs, this); if ((list != null) && !list.isEmpty()) { for (Shipment shipment : list) { if ((orderId != shipment.getOrderId())) { list = null; break; } } } } if (list == null) { StringBundler query = null; if (orderByComparator != null) { query = new StringBundler(3 + (orderByComparator.getOrderByFields().length * 2)); } else { query = new StringBundler(3); } query.append(_SQL_SELECT_SHIPMENT_WHERE); query.append(_FINDER_COLUMN_ORDERID_ORDERID_2); if (orderByComparator != null) { appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, orderByComparator); } else if (pagination) { query.append(ShipmentModelImpl.ORDER_BY_JPQL); } String sql = query.toString(); Session session = null; try { session = openSession(); Query q = session.createQuery(sql); QueryPos qPos = QueryPos.getInstance(q); qPos.add(orderId); if (!pagination) { list = (List<Shipment>) QueryUtil.list(q, getDialect(), start, end, false); Collections.sort(list); list = Collections.unmodifiableList(list); } else { list = (List<Shipment>) QueryUtil.list(q, getDialect(), start, end); } cacheResult(list); finderCache.putResult(finderPath, finderArgs, list); } catch (Exception e) { finderCache.removeResult(finderPath, finderArgs); throw processException(e); } finally { closeSession(session); } } return list; } /** * Returns the first shipment in the ordered set where orderId = ?. * * @param orderId the order ID * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) * @return the first matching shipment * @throws NoSuchShipmentException if a matching shipment could not be found */ @Override public Shipment findByOrderId_First(long orderId, OrderByComparator<Shipment> orderByComparator) throws NoSuchShipmentException { Shipment shipment = fetchByOrderId_First(orderId, orderByComparator); if (shipment != null) { return shipment; } StringBundler msg = new StringBundler(4); msg.append(_NO_SUCH_ENTITY_WITH_KEY); msg.append("orderId="); msg.append(orderId); msg.append(StringPool.CLOSE_CURLY_BRACE); throw new NoSuchShipmentException(msg.toString()); } /** * Returns the first shipment in the ordered set where orderId = ?. * * @param orderId the order ID * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) * @return the first matching shipment, or <code>null</code> if a matching shipment could not be found */ @Override public Shipment fetchByOrderId_First(long orderId, OrderByComparator<Shipment> orderByComparator) { List<Shipment> list = findByOrderId(orderId, 0, 1, orderByComparator); if (!list.isEmpty()) { return list.get(0); } return null; } /** * Returns the last shipment in the ordered set where orderId = ?. * * @param orderId the order ID * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) * @return the last matching shipment * @throws NoSuchShipmentException if a matching shipment could not be found */ @Override public Shipment findByOrderId_Last(long orderId, OrderByComparator<Shipment> orderByComparator) throws NoSuchShipmentException { Shipment shipment = fetchByOrderId_Last(orderId, orderByComparator); if (shipment != null) { return shipment; } StringBundler msg = new StringBundler(4); msg.append(_NO_SUCH_ENTITY_WITH_KEY); msg.append("orderId="); msg.append(orderId); msg.append(StringPool.CLOSE_CURLY_BRACE); throw new NoSuchShipmentException(msg.toString()); } /** * Returns the last shipment in the ordered set where orderId = ?. * * @param orderId the order ID * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) * @return the last matching shipment, or <code>null</code> if a matching shipment could not be found */ @Override public Shipment fetchByOrderId_Last(long orderId, OrderByComparator<Shipment> orderByComparator) { int count = countByOrderId(orderId); if (count == 0) { return null; } List<Shipment> list = findByOrderId(orderId, count - 1, count, orderByComparator); if (!list.isEmpty()) { return list.get(0); } return null; } /** * Returns the shipments before and after the current shipment in the ordered set where orderId = ?. * * @param shipmentId the primary key of the current shipment * @param orderId the order ID * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) * @return the previous, current, and next shipment * @throws NoSuchShipmentException if a shipment with the primary key could not be found */ @Override public Shipment[] findByOrderId_PrevAndNext(long shipmentId, long orderId, OrderByComparator<Shipment> orderByComparator) throws NoSuchShipmentException { Shipment shipment = findByPrimaryKey(shipmentId); Session session = null; try { session = openSession(); Shipment[] array = new ShipmentImpl[3]; array[0] = getByOrderId_PrevAndNext(session, shipment, orderId, orderByComparator, true); array[1] = shipment; array[2] = getByOrderId_PrevAndNext(session, shipment, orderId, orderByComparator, false); return array; } catch (Exception e) { throw processException(e); } finally { closeSession(session); } } protected Shipment getByOrderId_PrevAndNext(Session session, Shipment shipment, long orderId, OrderByComparator<Shipment> orderByComparator, boolean previous) { StringBundler query = null; if (orderByComparator != null) { query = new StringBundler(4 + (orderByComparator.getOrderByConditionFields().length * 3) + (orderByComparator.getOrderByFields().length * 3)); } else { query = new StringBundler(3); } query.append(_SQL_SELECT_SHIPMENT_WHERE); query.append(_FINDER_COLUMN_ORDERID_ORDERID_2); if (orderByComparator != null) { String[] orderByConditionFields = orderByComparator.getOrderByConditionFields(); if (orderByConditionFields.length > 0) { query.append(WHERE_AND); } for (int i = 0; i < orderByConditionFields.length; i++) { query.append(_ORDER_BY_ENTITY_ALIAS); query.append(orderByConditionFields[i]); if ((i + 1) < orderByConditionFields.length) { if (orderByComparator.isAscending() ^ previous) { query.append(WHERE_GREATER_THAN_HAS_NEXT); } else { query.append(WHERE_LESSER_THAN_HAS_NEXT); } } else { if (orderByComparator.isAscending() ^ previous) { query.append(WHERE_GREATER_THAN); } else { query.append(WHERE_LESSER_THAN); } } } query.append(ORDER_BY_CLAUSE); String[] orderByFields = orderByComparator.getOrderByFields(); for (int i = 0; i < orderByFields.length; i++) { query.append(_ORDER_BY_ENTITY_ALIAS); query.append(orderByFields[i]); if ((i + 1) < orderByFields.length) { if (orderByComparator.isAscending() ^ previous) { query.append(ORDER_BY_ASC_HAS_NEXT); } else { query.append(ORDER_BY_DESC_HAS_NEXT); } } else { if (orderByComparator.isAscending() ^ previous) { query.append(ORDER_BY_ASC); } else { query.append(ORDER_BY_DESC); } } } } else { query.append(ShipmentModelImpl.ORDER_BY_JPQL); } String sql = query.toString(); Query q = session.createQuery(sql); q.setFirstResult(0); q.setMaxResults(2); QueryPos qPos = QueryPos.getInstance(q); qPos.add(orderId); if (orderByComparator != null) { Object[] values = orderByComparator.getOrderByConditionValues(shipment); for (Object value : values) { qPos.add(value); } } List<Shipment> list = q.list(); if (list.size() == 2) { return list.get(1); } else { return null; } } /** * Returns all the shipments where orderId = any ?. * * <p> * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ShipmentModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. * </p> * * @param orderIds the order IDs * @return the matching shipments */ @Override public List<Shipment> findByOrderId(long[] orderIds) { return findByOrderId(orderIds, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null); } /** * Returns a range of all the shipments where orderId = any ?. * * <p> * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ShipmentModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. * </p> * * @param orderIds the order IDs * @param start the lower bound of the range of shipments * @param end the upper bound of the range of shipments (not inclusive) * @return the range of matching shipments */ @Override public List<Shipment> findByOrderId(long[] orderIds, int start, int end) { return findByOrderId(orderIds, start, end, null); } /** * Returns an ordered range of all the shipments where orderId = any ?. * * <p> * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ShipmentModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. * </p> * * @param orderIds the order IDs * @param start the lower bound of the range of shipments * @param end the upper bound of the range of shipments (not inclusive) * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) * @return the ordered range of matching shipments */ @Override public List<Shipment> findByOrderId(long[] orderIds, int start, int end, OrderByComparator<Shipment> orderByComparator) { return findByOrderId(orderIds, start, end, orderByComparator, true); } /** * Returns an ordered range of all the shipments where orderId = ?, optionally using the finder cache. * * <p> * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ShipmentModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. * </p> * * @param orderId the order ID * @param start the lower bound of the range of shipments * @param end the upper bound of the range of shipments (not inclusive) * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) * @param retrieveFromCache whether to retrieve from the finder cache * @return the ordered range of matching shipments */ @Override public List<Shipment> findByOrderId(long[] orderIds, int start, int end, OrderByComparator<Shipment> orderByComparator, boolean retrieveFromCache) { if (orderIds == null) { orderIds = new long[0]; } else if (orderIds.length > 1) { orderIds = ArrayUtil.unique(orderIds); Arrays.sort(orderIds); } if (orderIds.length == 1) { return findByOrderId(orderIds[0], start, end, orderByComparator); } boolean pagination = true; Object[] finderArgs = null; if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) && (orderByComparator == null)) { pagination = false; finderArgs = new Object[] { StringUtil.merge(orderIds) }; } else { finderArgs = new Object[] { StringUtil.merge(orderIds), start, end, orderByComparator }; } List<Shipment> list = null; if (retrieveFromCache) { list = (List<Shipment>) finderCache.getResult(FINDER_PATH_WITH_PAGINATION_FIND_BY_ORDERID, finderArgs, this); if ((list != null) && !list.isEmpty()) { for (Shipment shipment : list) { if (!ArrayUtil.contains(orderIds, shipment.getOrderId())) { list = null; break; } } } } if (list == null) { StringBundler query = new StringBundler(); query.append(_SQL_SELECT_SHIPMENT_WHERE); if (orderIds.length > 0) { query.append(StringPool.OPEN_PARENTHESIS); query.append(_FINDER_COLUMN_ORDERID_ORDERID_7); query.append(StringUtil.merge(orderIds)); query.append(StringPool.CLOSE_PARENTHESIS); query.append(StringPool.CLOSE_PARENTHESIS); } query.setStringAt(removeConjunction(query.stringAt(query.index() - 1)), query.index() - 1); if (orderByComparator != null) { appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, orderByComparator); } else if (pagination) { query.append(ShipmentModelImpl.ORDER_BY_JPQL); } String sql = query.toString(); Session session = null; try { session = openSession(); Query q = session.createQuery(sql); if (!pagination) { list = (List<Shipment>) QueryUtil.list(q, getDialect(), start, end, false); Collections.sort(list); list = Collections.unmodifiableList(list); } else { list = (List<Shipment>) QueryUtil.list(q, getDialect(), start, end); } cacheResult(list); finderCache.putResult(FINDER_PATH_WITH_PAGINATION_FIND_BY_ORDERID, finderArgs, list); } catch (Exception e) { finderCache.removeResult(FINDER_PATH_WITH_PAGINATION_FIND_BY_ORDERID, finderArgs); throw processException(e); } finally { closeSession(session); } } return list; } /** * Removes all the shipments where orderId = ? from the database. * * @param orderId the order ID */ @Override public void removeByOrderId(long orderId) { for (Shipment shipment : findByOrderId(orderId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) { remove(shipment); } } /** * Returns the number of shipments where orderId = ?. * * @param orderId the order ID * @return the number of matching shipments */ @Override public int countByOrderId(long orderId) { FinderPath finderPath = FINDER_PATH_COUNT_BY_ORDERID; Object[] finderArgs = new Object[] { orderId }; Long count = (Long) finderCache.getResult(finderPath, finderArgs, this); if (count == null) { StringBundler query = new StringBundler(2); query.append(_SQL_COUNT_SHIPMENT_WHERE); query.append(_FINDER_COLUMN_ORDERID_ORDERID_2); String sql = query.toString(); Session session = null; try { session = openSession(); Query q = session.createQuery(sql); QueryPos qPos = QueryPos.getInstance(q); qPos.add(orderId); count = (Long) q.uniqueResult(); finderCache.putResult(finderPath, finderArgs, count); } catch (Exception e) { finderCache.removeResult(finderPath, finderArgs); throw processException(e); } finally { closeSession(session); } } return count.intValue(); } /** * Returns the number of shipments where orderId = any ?. * * @param orderIds the order IDs * @return the number of matching shipments */ @Override public int countByOrderId(long[] orderIds) { if (orderIds == null) { orderIds = new long[0]; } else if (orderIds.length > 1) { orderIds = ArrayUtil.unique(orderIds); Arrays.sort(orderIds); } Object[] finderArgs = new Object[] { StringUtil.merge(orderIds) }; Long count = (Long) finderCache.getResult(FINDER_PATH_WITH_PAGINATION_COUNT_BY_ORDERID, finderArgs, this); if (count == null) { StringBundler query = new StringBundler(); query.append(_SQL_COUNT_SHIPMENT_WHERE); if (orderIds.length > 0) { query.append(StringPool.OPEN_PARENTHESIS); query.append(_FINDER_COLUMN_ORDERID_ORDERID_7); query.append(StringUtil.merge(orderIds)); query.append(StringPool.CLOSE_PARENTHESIS); query.append(StringPool.CLOSE_PARENTHESIS); } query.setStringAt(removeConjunction(query.stringAt(query.index() - 1)), query.index() - 1); String sql = query.toString(); Session session = null; try { session = openSession(); Query q = session.createQuery(sql); count = (Long) q.uniqueResult(); finderCache.putResult(FINDER_PATH_WITH_PAGINATION_COUNT_BY_ORDERID, finderArgs, count); } catch (Exception e) { finderCache.removeResult(FINDER_PATH_WITH_PAGINATION_COUNT_BY_ORDERID, finderArgs); throw processException(e); } finally { closeSession(session); } } return count.intValue(); } private static final String _FINDER_COLUMN_ORDERID_ORDERID_2 = "shipment.orderId = ?"; private static final String _FINDER_COLUMN_ORDERID_ORDERID_7 = "shipment.orderId IN ("; public static final FinderPath FINDER_PATH_FETCH_BY_DELIVERYNBR = new FinderPath( ShipmentModelImpl.ENTITY_CACHE_ENABLED, ShipmentModelImpl.FINDER_CACHE_ENABLED, ShipmentImpl.class, FINDER_CLASS_NAME_ENTITY, "fetchByDeliveryNbr", new String[] { String.class.getName() }, ShipmentModelImpl.DELIVERYNBR_COLUMN_BITMASK); public static final FinderPath FINDER_PATH_COUNT_BY_DELIVERYNBR = new FinderPath( ShipmentModelImpl.ENTITY_CACHE_ENABLED, ShipmentModelImpl.FINDER_CACHE_ENABLED, Long.class, FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByDeliveryNbr", new String[] { String.class.getName() }); /** * Returns the shipment where deliveryNbr = ? or throws a {@link NoSuchShipmentException} if it could not be found. * * @param deliveryNbr the delivery nbr * @return the matching shipment * @throws NoSuchShipmentException if a matching shipment could not be found */ @Override public Shipment findByDeliveryNbr(String deliveryNbr) throws NoSuchShipmentException { Shipment shipment = fetchByDeliveryNbr(deliveryNbr); if (shipment == null) { StringBundler msg = new StringBundler(4); msg.append(_NO_SUCH_ENTITY_WITH_KEY); msg.append("deliveryNbr="); msg.append(deliveryNbr); msg.append(StringPool.CLOSE_CURLY_BRACE); if (_log.isDebugEnabled()) { _log.debug(msg.toString()); } throw new NoSuchShipmentException(msg.toString()); } return shipment; } /** * Returns the shipment where deliveryNbr = ? or returns <code>null</code> if it could not be found. Uses the finder cache. * * @param deliveryNbr the delivery nbr * @return the matching shipment, or <code>null</code> if a matching shipment could not be found */ @Override public Shipment fetchByDeliveryNbr(String deliveryNbr) { return fetchByDeliveryNbr(deliveryNbr, true); } /** * Returns the shipment where deliveryNbr = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. * * @param deliveryNbr the delivery nbr * @param retrieveFromCache whether to retrieve from the finder cache * @return the matching shipment, or <code>null</code> if a matching shipment could not be found */ @Override public Shipment fetchByDeliveryNbr(String deliveryNbr, boolean retrieveFromCache) { Object[] finderArgs = new Object[] { deliveryNbr }; Object result = null; if (retrieveFromCache) { result = finderCache.getResult(FINDER_PATH_FETCH_BY_DELIVERYNBR, finderArgs, this); } if (result instanceof Shipment) { Shipment shipment = (Shipment) result; if (!Objects.equals(deliveryNbr, shipment.getDeliveryNbr())) { result = null; } } if (result == null) { StringBundler query = new StringBundler(3); query.append(_SQL_SELECT_SHIPMENT_WHERE); boolean bindDeliveryNbr = false; if (deliveryNbr == null) { query.append(_FINDER_COLUMN_DELIVERYNBR_DELIVERYNBR_1); } else if (deliveryNbr.equals(StringPool.BLANK)) { query.append(_FINDER_COLUMN_DELIVERYNBR_DELIVERYNBR_3); } else { bindDeliveryNbr = true; query.append(_FINDER_COLUMN_DELIVERYNBR_DELIVERYNBR_2); } String sql = query.toString(); Session session = null; try { session = openSession(); Query q = session.createQuery(sql); QueryPos qPos = QueryPos.getInstance(q); if (bindDeliveryNbr) { qPos.add(deliveryNbr); } List<Shipment> list = q.list(); if (list.isEmpty()) { finderCache.putResult(FINDER_PATH_FETCH_BY_DELIVERYNBR, finderArgs, list); } else { Shipment shipment = list.get(0); result = shipment; cacheResult(shipment); if ((shipment.getDeliveryNbr() == null) || !shipment.getDeliveryNbr().equals(deliveryNbr)) { finderCache.putResult(FINDER_PATH_FETCH_BY_DELIVERYNBR, finderArgs, shipment); } } } catch (Exception e) { finderCache.removeResult(FINDER_PATH_FETCH_BY_DELIVERYNBR, finderArgs); throw processException(e); } finally { closeSession(session); } } if (result instanceof List<?>) { return null; } else { return (Shipment) result; } } /** * Removes the shipment where deliveryNbr = ? from the database. * * @param deliveryNbr the delivery nbr * @return the shipment that was removed */ @Override public Shipment removeByDeliveryNbr(String deliveryNbr) throws NoSuchShipmentException { Shipment shipment = findByDeliveryNbr(deliveryNbr); return remove(shipment); } /** * Returns the number of shipments where deliveryNbr = ?. * * @param deliveryNbr the delivery nbr * @return the number of matching shipments */ @Override public int countByDeliveryNbr(String deliveryNbr) { FinderPath finderPath = FINDER_PATH_COUNT_BY_DELIVERYNBR; Object[] finderArgs = new Object[] { deliveryNbr }; Long count = (Long) finderCache.getResult(finderPath, finderArgs, this); if (count == null) { StringBundler query = new StringBundler(2); query.append(_SQL_COUNT_SHIPMENT_WHERE); boolean bindDeliveryNbr = false; if (deliveryNbr == null) { query.append(_FINDER_COLUMN_DELIVERYNBR_DELIVERYNBR_1); } else if (deliveryNbr.equals(StringPool.BLANK)) { query.append(_FINDER_COLUMN_DELIVERYNBR_DELIVERYNBR_3); } else { bindDeliveryNbr = true; query.append(_FINDER_COLUMN_DELIVERYNBR_DELIVERYNBR_2); } String sql = query.toString(); Session session = null; try { session = openSession(); Query q = session.createQuery(sql); QueryPos qPos = QueryPos.getInstance(q); if (bindDeliveryNbr) { qPos.add(deliveryNbr); } count = (Long) q.uniqueResult(); finderCache.putResult(finderPath, finderArgs, count); } catch (Exception e) { finderCache.removeResult(finderPath, finderArgs); throw processException(e); } finally { closeSession(session); } } return count.intValue(); } private static final String _FINDER_COLUMN_DELIVERYNBR_DELIVERYNBR_1 = "shipment.deliveryNbr IS NULL"; private static final String _FINDER_COLUMN_DELIVERYNBR_DELIVERYNBR_2 = "shipment.deliveryNbr = ?"; private static final String _FINDER_COLUMN_DELIVERYNBR_DELIVERYNBR_3 = "(shipment.deliveryNbr IS NULL OR shipment.deliveryNbr = '')"; public ShipmentPersistenceImpl() { setModelClass(Shipment.class); } /** * Caches the shipment in the entity cache if it is enabled. * * @param shipment the shipment */ @Override public void cacheResult(Shipment shipment) { entityCache.putResult(ShipmentModelImpl.ENTITY_CACHE_ENABLED, ShipmentImpl.class, shipment.getPrimaryKey(), shipment); finderCache.putResult(FINDER_PATH_FETCH_BY_DELIVERYNBR, new Object[] { shipment.getDeliveryNbr() }, shipment); shipment.resetOriginalValues(); } /** * Caches the shipments in the entity cache if it is enabled. * * @param shipments the shipments */ @Override public void cacheResult(List<Shipment> shipments) { for (Shipment shipment : shipments) { if (entityCache.getResult(ShipmentModelImpl.ENTITY_CACHE_ENABLED, ShipmentImpl.class, shipment.getPrimaryKey()) == null) { cacheResult(shipment); } else { shipment.resetOriginalValues(); } } } /** * Clears the cache for all shipments. * * <p> * The {@link EntityCache} and {@link FinderCache} are both cleared by this method. * </p> */ @Override public void clearCache() { entityCache.clearCache(ShipmentImpl.class); finderCache.clearCache(FINDER_CLASS_NAME_ENTITY); finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION); finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION); } /** * Clears the cache for the shipment. * * <p> * The {@link EntityCache} and {@link FinderCache} are both cleared by this method. * </p> */ @Override public void clearCache(Shipment shipment) { entityCache.removeResult(ShipmentModelImpl.ENTITY_CACHE_ENABLED, ShipmentImpl.class, shipment.getPrimaryKey()); finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION); finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION); clearUniqueFindersCache((ShipmentModelImpl) shipment); } @Override public void clearCache(List<Shipment> shipments) { finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION); finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION); for (Shipment shipment : shipments) { entityCache.removeResult(ShipmentModelImpl.ENTITY_CACHE_ENABLED, ShipmentImpl.class, shipment.getPrimaryKey()); clearUniqueFindersCache((ShipmentModelImpl) shipment); } } protected void cacheUniqueFindersCache(ShipmentModelImpl shipmentModelImpl, boolean isNew) { if (isNew) { Object[] args = new Object[] { shipmentModelImpl.getDeliveryNbr() }; finderCache.putResult(FINDER_PATH_COUNT_BY_DELIVERYNBR, args, Long.valueOf(1)); finderCache.putResult(FINDER_PATH_FETCH_BY_DELIVERYNBR, args, shipmentModelImpl); } else { if ((shipmentModelImpl.getColumnBitmask() & FINDER_PATH_FETCH_BY_DELIVERYNBR.getColumnBitmask()) != 0) { Object[] args = new Object[] { shipmentModelImpl.getDeliveryNbr() }; finderCache.putResult(FINDER_PATH_COUNT_BY_DELIVERYNBR, args, Long.valueOf(1)); finderCache.putResult(FINDER_PATH_FETCH_BY_DELIVERYNBR, args, shipmentModelImpl); } } } protected void clearUniqueFindersCache(ShipmentModelImpl shipmentModelImpl) { Object[] args = new Object[] { shipmentModelImpl.getDeliveryNbr() }; finderCache.removeResult(FINDER_PATH_COUNT_BY_DELIVERYNBR, args); finderCache.removeResult(FINDER_PATH_FETCH_BY_DELIVERYNBR, args); if ((shipmentModelImpl.getColumnBitmask() & FINDER_PATH_FETCH_BY_DELIVERYNBR.getColumnBitmask()) != 0) { args = new Object[] { shipmentModelImpl.getOriginalDeliveryNbr() }; finderCache.removeResult(FINDER_PATH_COUNT_BY_DELIVERYNBR, args); finderCache.removeResult(FINDER_PATH_FETCH_BY_DELIVERYNBR, args); } } /** * Creates a new shipment with the primary key. Does not add the shipment to the database. * * @param shipmentId the primary key for the new shipment * @return the new shipment */ @Override public Shipment create(long shipmentId) { Shipment shipment = new ShipmentImpl(); shipment.setNew(true); shipment.setPrimaryKey(shipmentId); shipment.setCompanyId(companyProvider.getCompanyId()); return shipment; } /** * Removes the shipment with the primary key from the database. Also notifies the appropriate model listeners. * * @param shipmentId the primary key of the shipment * @return the shipment that was removed * @throws NoSuchShipmentException if a shipment with the primary key could not be found */ @Override public Shipment remove(long shipmentId) throws NoSuchShipmentException { return remove((Serializable) shipmentId); } /** * Removes the shipment with the primary key from the database. Also notifies the appropriate model listeners. * * @param primaryKey the primary key of the shipment * @return the shipment that was removed * @throws NoSuchShipmentException if a shipment with the primary key could not be found */ @Override public Shipment remove(Serializable primaryKey) throws NoSuchShipmentException { Session session = null; try { session = openSession(); Shipment shipment = (Shipment) session.get(ShipmentImpl.class, primaryKey); if (shipment == null) { if (_log.isDebugEnabled()) { _log.debug(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey); } throw new NoSuchShipmentException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey); } return remove(shipment); } catch (NoSuchShipmentException nsee) { throw nsee; } catch (Exception e) { throw processException(e); } finally { closeSession(session); } } @Override protected Shipment removeImpl(Shipment shipment) { shipment = toUnwrappedModel(shipment); Session session = null; try { session = openSession(); if (!session.contains(shipment)) { shipment = (Shipment) session.get(ShipmentImpl.class, shipment.getPrimaryKeyObj()); } if (shipment != null) { session.delete(shipment); } } catch (Exception e) { throw processException(e); } finally { closeSession(session); } if (shipment != null) { clearCache(shipment); } return shipment; } @Override public Shipment updateImpl(Shipment shipment) { shipment = toUnwrappedModel(shipment); boolean isNew = shipment.isNew(); ShipmentModelImpl shipmentModelImpl = (ShipmentModelImpl) shipment; ServiceContext serviceContext = ServiceContextThreadLocal.getServiceContext(); Date now = new Date(); if (isNew && (shipment.getCreateDate() == null)) { if (serviceContext == null) { shipment.setCreateDate(now); } else { shipment.setCreateDate(serviceContext.getCreateDate(now)); } } if (!shipmentModelImpl.hasSetModifiedDate()) { if (serviceContext == null) { shipment.setModifiedDate(now); } else { shipment.setModifiedDate(serviceContext.getModifiedDate(now)); } } Session session = null; try { session = openSession(); if (shipment.isNew()) { session.save(shipment); shipment.setNew(false); } else { shipment = (Shipment) session.merge(shipment); } } catch (Exception e) { throw processException(e); } finally { closeSession(session); } finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION); if (isNew || !ShipmentModelImpl.COLUMN_BITMASK_ENABLED) { finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION); } else { if ((shipmentModelImpl.getColumnBitmask() & FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_SHIPTOID.getColumnBitmask()) != 0) { Object[] args = new Object[] { shipmentModelImpl.getOriginalShipToId() }; finderCache.removeResult(FINDER_PATH_COUNT_BY_SHIPTOID, args); finderCache.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_SHIPTOID, args); args = new Object[] { shipmentModelImpl.getShipToId() }; finderCache.removeResult(FINDER_PATH_COUNT_BY_SHIPTOID, args); finderCache.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_SHIPTOID, args); } if ((shipmentModelImpl.getColumnBitmask() & FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_ORDERID.getColumnBitmask()) != 0) { Object[] args = new Object[] { shipmentModelImpl.getOriginalOrderId() }; finderCache.removeResult(FINDER_PATH_COUNT_BY_ORDERID, args); finderCache.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_ORDERID, args); args = new Object[] { shipmentModelImpl.getOrderId() }; finderCache.removeResult(FINDER_PATH_COUNT_BY_ORDERID, args); finderCache.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_ORDERID, args); } } entityCache.putResult(ShipmentModelImpl.ENTITY_CACHE_ENABLED, ShipmentImpl.class, shipment.getPrimaryKey(), shipment, false); clearUniqueFindersCache(shipmentModelImpl); cacheUniqueFindersCache(shipmentModelImpl, isNew); shipment.resetOriginalValues(); return shipment; } protected Shipment toUnwrappedModel(Shipment shipment) { if (shipment instanceof ShipmentImpl) { return shipment; } ShipmentImpl shipmentImpl = new ShipmentImpl(); shipmentImpl.setNew(shipment.isNew()); shipmentImpl.setPrimaryKey(shipment.getPrimaryKey()); shipmentImpl.setShipmentId(shipment.getShipmentId()); shipmentImpl.setGroupId(shipment.getGroupId()); shipmentImpl.setCompanyId(shipment.getCompanyId()); shipmentImpl.setUserId(shipment.getUserId()); shipmentImpl.setUserName(shipment.getUserName()); shipmentImpl.setCreateDate(shipment.getCreateDate()); shipmentImpl.setModifiedDate(shipment.getModifiedDate()); shipmentImpl.setOrderId(shipment.getOrderId()); shipmentImpl.setShipmentDate(shipment.getShipmentDate()); shipmentImpl.setShipmentQty(shipment.getShipmentQty()); shipmentImpl.setShipmentUom(shipment.getShipmentUom()); shipmentImpl.setPalletQty(shipment.getPalletQty()); shipmentImpl.setInvoiceNo(shipment.getInvoiceNo()); shipmentImpl.setBolNo(shipment.getBolNo()); shipmentImpl.setCarrierName(shipment.getCarrierName()); shipmentImpl.setProNo(shipment.getProNo()); shipmentImpl.setShipToId(shipment.getShipToId()); shipmentImpl.setReleasePo(shipment.getReleasePo()); shipmentImpl.setPlantNo(shipment.getPlantNo()); shipmentImpl.setDeliveryNbr(shipment.getDeliveryNbr()); return shipmentImpl; } /** * Returns the shipment with the primary key or throws a {@link com.liferay.portal.kernel.exception.NoSuchModelException} if it could not be found. * * @param primaryKey the primary key of the shipment * @return the shipment * @throws NoSuchShipmentException if a shipment with the primary key could not be found */ @Override public Shipment findByPrimaryKey(Serializable primaryKey) throws NoSuchShipmentException { Shipment shipment = fetchByPrimaryKey(primaryKey); if (shipment == null) { if (_log.isDebugEnabled()) { _log.debug(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey); } throw new NoSuchShipmentException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey); } return shipment; } /** * Returns the shipment with the primary key or throws a {@link NoSuchShipmentException} if it could not be found. * * @param shipmentId the primary key of the shipment * @return the shipment * @throws NoSuchShipmentException if a shipment with the primary key could not be found */ @Override public Shipment findByPrimaryKey(long shipmentId) throws NoSuchShipmentException { return findByPrimaryKey((Serializable) shipmentId); } /** * Returns the shipment with the primary key or returns <code>null</code> if it could not be found. * * @param primaryKey the primary key of the shipment * @return the shipment, or <code>null</code> if a shipment with the primary key could not be found */ @Override public Shipment fetchByPrimaryKey(Serializable primaryKey) { Serializable serializable = entityCache.getResult(ShipmentModelImpl.ENTITY_CACHE_ENABLED, ShipmentImpl.class, primaryKey); if (serializable == nullModel) { return null; } Shipment shipment = (Shipment) serializable; if (shipment == null) { Session session = null; try { session = openSession(); shipment = (Shipment) session.get(ShipmentImpl.class, primaryKey); if (shipment != null) { cacheResult(shipment); } else { entityCache.putResult(ShipmentModelImpl.ENTITY_CACHE_ENABLED, ShipmentImpl.class, primaryKey, nullModel); } } catch (Exception e) { entityCache.removeResult(ShipmentModelImpl.ENTITY_CACHE_ENABLED, ShipmentImpl.class, primaryKey); throw processException(e); } finally { closeSession(session); } } return shipment; } /** * Returns the shipment with the primary key or returns <code>null</code> if it could not be found. * * @param shipmentId the primary key of the shipment * @return the shipment, or <code>null</code> if a shipment with the primary key could not be found */ @Override public Shipment fetchByPrimaryKey(long shipmentId) { return fetchByPrimaryKey((Serializable) shipmentId); } @Override public Map<Serializable, Shipment> fetchByPrimaryKeys(Set<Serializable> primaryKeys) { if (primaryKeys.isEmpty()) { return Collections.emptyMap(); } Map<Serializable, Shipment> map = new HashMap<Serializable, Shipment>(); if (primaryKeys.size() == 1) { Iterator<Serializable> iterator = primaryKeys.iterator(); Serializable primaryKey = iterator.next(); Shipment shipment = fetchByPrimaryKey(primaryKey); if (shipment != null) { map.put(primaryKey, shipment); } return map; } Set<Serializable> uncachedPrimaryKeys = null; for (Serializable primaryKey : primaryKeys) { Serializable serializable = entityCache.getResult(ShipmentModelImpl.ENTITY_CACHE_ENABLED, ShipmentImpl.class, primaryKey); if (serializable != nullModel) { if (serializable == null) { if (uncachedPrimaryKeys == null) { uncachedPrimaryKeys = new HashSet<Serializable>(); } uncachedPrimaryKeys.add(primaryKey); } else { map.put(primaryKey, (Shipment) serializable); } } } if (uncachedPrimaryKeys == null) { return map; } StringBundler query = new StringBundler((uncachedPrimaryKeys.size() * 2) + 1); query.append(_SQL_SELECT_SHIPMENT_WHERE_PKS_IN); for (Serializable primaryKey : uncachedPrimaryKeys) { query.append(String.valueOf(primaryKey)); query.append(StringPool.COMMA); } query.setIndex(query.index() - 1); query.append(StringPool.CLOSE_PARENTHESIS); String sql = query.toString(); Session session = null; try { session = openSession(); Query q = session.createQuery(sql); for (Shipment shipment : (List<Shipment>) q.list()) { map.put(shipment.getPrimaryKeyObj(), shipment); cacheResult(shipment); uncachedPrimaryKeys.remove(shipment.getPrimaryKeyObj()); } for (Serializable primaryKey : uncachedPrimaryKeys) { entityCache.putResult(ShipmentModelImpl.ENTITY_CACHE_ENABLED, ShipmentImpl.class, primaryKey, nullModel); } } catch (Exception e) { throw processException(e); } finally { closeSession(session); } return map; } /** * Returns all the shipments. * * @return the shipments */ @Override public List<Shipment> findAll() { return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null); } /** * Returns a range of all the shipments. * * <p> * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ShipmentModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. * </p> * * @param start the lower bound of the range of shipments * @param end the upper bound of the range of shipments (not inclusive) * @return the range of shipments */ @Override public List<Shipment> findAll(int start, int end) { return findAll(start, end, null); } /** * Returns an ordered range of all the shipments. * * <p> * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ShipmentModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. * </p> * * @param start the lower bound of the range of shipments * @param end the upper bound of the range of shipments (not inclusive) * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) * @return the ordered range of shipments */ @Override public List<Shipment> findAll(int start, int end, OrderByComparator<Shipment> orderByComparator) { return findAll(start, end, orderByComparator, true); } /** * Returns an ordered range of all the shipments. * * <p> * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ShipmentModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. * </p> * * @param start the lower bound of the range of shipments * @param end the upper bound of the range of shipments (not inclusive) * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) * @param retrieveFromCache whether to retrieve from the finder cache * @return the ordered range of shipments */ @Override public List<Shipment> findAll(int start, int end, OrderByComparator<Shipment> orderByComparator, boolean retrieveFromCache) { boolean pagination = true; FinderPath finderPath = null; Object[] finderArgs = null; if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) && (orderByComparator == null)) { pagination = false; finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL; finderArgs = FINDER_ARGS_EMPTY; } else { finderPath = FINDER_PATH_WITH_PAGINATION_FIND_ALL; finderArgs = new Object[] { start, end, orderByComparator }; } List<Shipment> list = null; if (retrieveFromCache) { list = (List<Shipment>) finderCache.getResult(finderPath, finderArgs, this); } if (list == null) { StringBundler query = null; String sql = null; if (orderByComparator != null) { query = new StringBundler(2 + (orderByComparator.getOrderByFields().length * 2)); query.append(_SQL_SELECT_SHIPMENT); appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, orderByComparator); sql = query.toString(); } else { sql = _SQL_SELECT_SHIPMENT; if (pagination) { sql = sql.concat(ShipmentModelImpl.ORDER_BY_JPQL); } } Session session = null; try { session = openSession(); Query q = session.createQuery(sql); if (!pagination) { list = (List<Shipment>) QueryUtil.list(q, getDialect(), start, end, false); Collections.sort(list); list = Collections.unmodifiableList(list); } else { list = (List<Shipment>) QueryUtil.list(q, getDialect(), start, end); } cacheResult(list); finderCache.putResult(finderPath, finderArgs, list); } catch (Exception e) { finderCache.removeResult(finderPath, finderArgs); throw processException(e); } finally { closeSession(session); } } return list; } /** * Removes all the shipments from the database. * */ @Override public void removeAll() { for (Shipment shipment : findAll()) { remove(shipment); } } /** * Returns the number of shipments. * * @return the number of shipments */ @Override public int countAll() { Long count = (Long) finderCache.getResult(FINDER_PATH_COUNT_ALL, FINDER_ARGS_EMPTY, this); if (count == null) { Session session = null; try { session = openSession(); Query q = session.createQuery(_SQL_COUNT_SHIPMENT); count = (Long) q.uniqueResult(); finderCache.putResult(FINDER_PATH_COUNT_ALL, FINDER_ARGS_EMPTY, count); } catch (Exception e) { finderCache.removeResult(FINDER_PATH_COUNT_ALL, FINDER_ARGS_EMPTY); throw processException(e); } finally { closeSession(session); } } return count.intValue(); } @Override protected Map<String, Integer> getTableColumnsMap() { return ShipmentModelImpl.TABLE_COLUMNS_MAP; } /** * Initializes the shipment persistence. */ public void afterPropertiesSet() { } public void destroy() { entityCache.removeCache(ShipmentImpl.class.getName()); finderCache.removeCache(FINDER_CLASS_NAME_ENTITY); finderCache.removeCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION); finderCache.removeCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION); } @ServiceReference(type = CompanyProviderWrapper.class) protected CompanyProvider companyProvider; @ServiceReference(type = EntityCache.class) protected EntityCache entityCache; @ServiceReference(type = FinderCache.class) protected FinderCache finderCache; private static final String _SQL_SELECT_SHIPMENT = "SELECT shipment FROM Shipment shipment"; private static final String _SQL_SELECT_SHIPMENT_WHERE_PKS_IN = "SELECT shipment FROM Shipment shipment WHERE shipmentId IN ("; private static final String _SQL_SELECT_SHIPMENT_WHERE = "SELECT shipment FROM Shipment shipment WHERE "; private static final String _SQL_COUNT_SHIPMENT = "SELECT COUNT(shipment) FROM Shipment shipment"; private static final String _SQL_COUNT_SHIPMENT_WHERE = "SELECT COUNT(shipment) FROM Shipment shipment WHERE "; private static final String _ORDER_BY_ENTITY_ALIAS = "shipment."; private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No Shipment exists with the primary key "; private static final String _NO_SUCH_ENTITY_WITH_KEY = "No Shipment exists with the key {"; private static final Log _log = LogFactoryUtil.getLog(ShipmentPersistenceImpl.class); }