Source code

001// --------------------------------------------------------------------------------
002// Copyright 2002-2025 Echo Three, LLC
003//
004// Licensed under the Apache License, Version 2.0 (the "License");
005// you may not use this file except in compliance with the License.
006// You may obtain a copy of the License at
007//
008//     http://www.apache.org/licenses/LICENSE-2.0
009//
010// Unless required by applicable law or agreed to in writing, software
011// distributed under the License is distributed on an "AS IS" BASIS,
012// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013// See the License for the specific language governing permissions and
014// limitations under the License.
015// --------------------------------------------------------------------------------
016// Generated File -- DO NOT EDIT BY HAND
017// --------------------------------------------------------------------------------
018
019/**
020 * UnitOfMeasureEquivalentFactory.java
021 */
022
023package com.echothree.model.data.uom.server.factory;
024
025import com.echothree.model.data.uom.common.pk.UnitOfMeasureTypePK;
026
027import com.echothree.model.data.uom.server.entity.UnitOfMeasureType;
028
029import com.echothree.model.data.uom.common.UnitOfMeasureEquivalentConstants;
030import com.echothree.model.data.uom.common.pk.UnitOfMeasureEquivalentPK;
031import com.echothree.model.data.uom.server.value.UnitOfMeasureEquivalentValue;
032import com.echothree.model.data.uom.server.entity.UnitOfMeasureEquivalent;
033import com.echothree.util.common.exception.PersistenceDatabaseException;
034import com.echothree.util.common.exception.PersistenceDatabaseUpdateException;
035import com.echothree.util.common.exception.PersistenceNotNullException;
036import com.echothree.util.server.persistence.BaseFactory;
037import com.echothree.util.server.persistence.EntityIdGenerator;
038import com.echothree.util.server.persistence.EntityPermission;
039import com.echothree.util.server.persistence.PersistenceDebugFlags;
040import com.echothree.util.server.persistence.Session;
041import com.echothree.util.server.persistence.ThreadSession;
042import java.sql.PreparedStatement;
043import java.sql.ResultSet;
044import java.sql.SQLException;
045import java.sql.Types;
046import java.io.ByteArrayInputStream;
047import java.io.StringReader;
048import java.util.ArrayList;
049import java.util.Collection;
050import java.util.HashSet;
051import java.util.List;
052import java.util.Map;
053import java.util.Set;
054import javax.enterprise.context.ApplicationScoped;
055import javax.enterprise.inject.spi.CDI;
056import org.apache.commons.logging.Log;
057import org.apache.commons.logging.LogFactory;
058
059@ApplicationScoped
060public class UnitOfMeasureEquivalentFactory
061        implements BaseFactory<UnitOfMeasureEquivalentPK, UnitOfMeasureEquivalent> {
062    
063    //final private static Log log = LogFactory.getLog(UnitOfMeasureEquivalentFactory.class);
064    
065    final private static String SQL_SELECT_READ_ONLY = "SELECT uomeq_unitofmeasureequivalentid, uomeq_fromunitofmeasuretypeid, uomeq_tounitofmeasuretypeid, uomeq_toquantity, uomeq_fromtime, uomeq_thrutime FROM unitofmeasureequivalents WHERE uomeq_unitofmeasureequivalentid = ?";
066    final private static String SQL_SELECT_READ_WRITE = "SELECT uomeq_unitofmeasureequivalentid, uomeq_fromunitofmeasuretypeid, uomeq_tounitofmeasuretypeid, uomeq_toquantity, uomeq_fromtime, uomeq_thrutime FROM unitofmeasureequivalents WHERE uomeq_unitofmeasureequivalentid = ? FOR UPDATE";
067    final private static String SQL_INSERT = "INSERT INTO unitofmeasureequivalents (uomeq_unitofmeasureequivalentid, uomeq_fromunitofmeasuretypeid, uomeq_tounitofmeasuretypeid, uomeq_toquantity, uomeq_fromtime, uomeq_thrutime) VALUES (?, ?, ?, ?, ?, ?)";
068    final private static String SQL_UPDATE = "UPDATE unitofmeasureequivalents SET uomeq_fromunitofmeasuretypeid = ?, uomeq_tounitofmeasuretypeid = ?, uomeq_toquantity = ?, uomeq_fromtime = ?, uomeq_thrutime = ? WHERE uomeq_unitofmeasureequivalentid = ?";
069    final private static String SQL_DELETE = "DELETE FROM unitofmeasureequivalents WHERE uomeq_unitofmeasureequivalentid = ?";
070    final private static String SQL_VALID = "SELECT COUNT(*) FROM unitofmeasureequivalents WHERE uomeq_unitofmeasureequivalentid = ?";
071    
072    final private static String PK_COLUMN = "uomeq_unitofmeasureequivalentid";
073    final private static String ALL_COLUMNS = "uomeq_unitofmeasureequivalentid, uomeq_fromunitofmeasuretypeid, uomeq_tounitofmeasuretypeid, uomeq_toquantity, uomeq_fromtime, uomeq_thrutime";
074    final public static String TABLE_NAME = "unitofmeasureequivalents";
075    
076    final public static String UOMEQ_UNITOFMEASUREEQUIVALENTID = "uomeq_unitofmeasureequivalentid";
077    final public static String UOMEQ_FROMUNITOFMEASURETYPEID = "uomeq_fromunitofmeasuretypeid";
078    final public static String UOMEQ_TOUNITOFMEASURETYPEID = "uomeq_tounitofmeasuretypeid";
079    final public static String UOMEQ_TOQUANTITY = "uomeq_toquantity";
080    final public static String UOMEQ_FROMTIME = "uomeq_fromtime";
081    final public static String UOMEQ_THRUTIME = "uomeq_thrutime";
082    
083    final private static EntityIdGenerator entityIdGenerator = new EntityIdGenerator(UnitOfMeasureEquivalentConstants.COMPONENT_VENDOR_NAME, UnitOfMeasureEquivalentConstants.ENTITY_TYPE_NAME);
084    
085    /** Creates a new instance of UnitOfMeasureEquivalentFactory */
086    protected UnitOfMeasureEquivalentFactory() {
087        super();
088    }
089    
090    public static UnitOfMeasureEquivalentFactory getInstance() {
091        return CDI.current().select(UnitOfMeasureEquivalentFactory.class).get();
092    }
093    
094    @Override
095    public String getPKColumn() {
096        return PK_COLUMN;
097    }
098    
099    @Override
100    public String getAllColumns() {
101        return ALL_COLUMNS;
102    }
103    
104    @Override
105    public String getTableName() {
106        return TABLE_NAME;
107    }
108    
109    @Override
110    public String getComponentVendorName() {
111        return UnitOfMeasureEquivalentConstants.COMPONENT_VENDOR_NAME;
112    }
113    
114    @Override
115    public String getEntityTypeName() {
116        return UnitOfMeasureEquivalentConstants.ENTITY_TYPE_NAME;
117    }
118    
119    public PreparedStatement prepareStatement(String query) {
120        return ThreadSession.currentSession().prepareStatement(UnitOfMeasureEquivalentFactory.class, query);
121    }
122    
123    public UnitOfMeasureEquivalentPK getNextPK() {
124        return new UnitOfMeasureEquivalentPK(entityIdGenerator.getNextEntityId());
125    }
126    
127    public Set<UnitOfMeasureEquivalentPK> getPKsFromResultSetAsSet(ResultSet rs)
128            throws PersistenceDatabaseException {
129        Set<UnitOfMeasureEquivalentPK> _result = new HashSet<>();
130        
131        try {
132            while(rs.next()) {
133                _result.add(getPKFromResultSet(rs));
134            }
135        } catch (SQLException se) {
136            throw new PersistenceDatabaseException(se);
137        }
138        
139        return _result;
140    }
141    
142    public java.util.List<UnitOfMeasureEquivalentPK> getPKsFromResultSetAsList(ResultSet rs)
143            throws PersistenceDatabaseException {
144        java.util.List<UnitOfMeasureEquivalentPK> _result = new ArrayList<>();
145        
146        try {
147            while(rs.next()) {
148                _result.add(getPKFromResultSet(rs));
149            }
150        } catch (SQLException se) {
151            throw new PersistenceDatabaseException(se);
152        }
153        
154        return _result;
155    }
156    
157    public UnitOfMeasureEquivalentPK getPKFromResultSet(ResultSet rs)
158            throws PersistenceDatabaseException {
159        UnitOfMeasureEquivalentPK _result;
160        
161        try {
162            long uomeq_unitofmeasureequivalentid = rs.getLong(UOMEQ_UNITOFMEASUREEQUIVALENTID);
163            Long _entityId = rs.wasNull() ? null : uomeq_unitofmeasureequivalentid;
164            
165            _result = new UnitOfMeasureEquivalentPK(_entityId);
166        } catch (SQLException se) {
167            throw new PersistenceDatabaseException(se);
168        }
169        
170        return _result;
171    }
172    
173    public java.util.List<UnitOfMeasureEquivalentValue> getValuesFromPKs(Session session, Collection<UnitOfMeasureEquivalentPK> pks)
174            throws PersistenceDatabaseException {
175        java.util.List<UnitOfMeasureEquivalentValue> _values = new ArrayList<>(pks.size());
176        
177        for(UnitOfMeasureEquivalentPK _pk: pks) {
178            _values.add(getValueFromPK(session, _pk));
179        }
180        
181        return _values;
182    }
183    
184    public UnitOfMeasureEquivalentValue getValueFromPK(Session session, UnitOfMeasureEquivalentPK pk)
185            throws PersistenceDatabaseException {
186        UnitOfMeasureEquivalentValue _value;
187        
188        // See if we already have the entity in the session cache
189        UnitOfMeasureEquivalent _entity = (UnitOfMeasureEquivalent)session.getEntity(pk);
190        if(_entity == null)
191            _value = getEntityFromPK(session, EntityPermission.READ_ONLY, pk).getUnitOfMeasureEquivalentValue();
192        else
193            _value = _entity.getUnitOfMeasureEquivalentValue();
194        
195        return _value;
196    }
197    
198    public java.util.List<UnitOfMeasureEquivalentValue> getValuesFromResultSet(Session session, ResultSet rs)
199            throws PersistenceDatabaseException {
200        java.util.List<UnitOfMeasureEquivalentValue> _result = new ArrayList<>();
201        
202        try {
203            while(rs.next()) {
204                _result.add(getValueFromResultSet(session, rs));
205            }
206        } catch (SQLException se) {
207            throw new PersistenceDatabaseException(se);
208        }
209        
210        return _result;
211    }
212    
213    public UnitOfMeasureEquivalentValue getValueFromResultSet(Session session, ResultSet rs)
214            throws PersistenceDatabaseException {
215        UnitOfMeasureEquivalentValue _value;
216        
217        try {
218            Long uomeq_unitofmeasureequivalentid = rs.getLong(UOMEQ_UNITOFMEASUREEQUIVALENTID);
219            UnitOfMeasureEquivalentPK _pk = new UnitOfMeasureEquivalentPK(uomeq_unitofmeasureequivalentid);
220            
221            // See if we already have the entity in the session cache
222            UnitOfMeasureEquivalent _entity = (UnitOfMeasureEquivalent)session.getEntity(_pk);
223            
224            if(_entity == null) {
225                Long uomeq_fromunitofmeasuretypeid = rs.getLong(UOMEQ_FROMUNITOFMEASURETYPEID);
226                if(rs.wasNull())
227                    uomeq_fromunitofmeasuretypeid = null;
228                
229                Long uomeq_tounitofmeasuretypeid = rs.getLong(UOMEQ_TOUNITOFMEASURETYPEID);
230                if(rs.wasNull())
231                    uomeq_tounitofmeasuretypeid = null;
232                
233                Long uomeq_toquantity = rs.getLong(UOMEQ_TOQUANTITY);
234                if(rs.wasNull())
235                    uomeq_toquantity = null;
236                
237                Long uomeq_fromtime = rs.getLong(UOMEQ_FROMTIME);
238                if(rs.wasNull())
239                    uomeq_fromtime = null;
240                
241                Long uomeq_thrutime = rs.getLong(UOMEQ_THRUTIME);
242                if(rs.wasNull())
243                    uomeq_thrutime = null;
244                
245                _value = new UnitOfMeasureEquivalentValue(_pk, new UnitOfMeasureTypePK(uomeq_fromunitofmeasuretypeid), new UnitOfMeasureTypePK(uomeq_tounitofmeasuretypeid), uomeq_toquantity, uomeq_fromtime, uomeq_thrutime);
246            } else
247                _value = _entity.getUnitOfMeasureEquivalentValue();
248        } catch (SQLException se) {
249            throw new PersistenceDatabaseException(se);
250        }
251        
252        return _value;
253    }
254    
255    public java.util.List<UnitOfMeasureEquivalent> getEntitiesFromPKs(EntityPermission entityPermission, Collection<UnitOfMeasureEquivalentPK> pks)
256            throws PersistenceDatabaseException {
257        return getEntitiesFromPKs(ThreadSession.currentSession(), entityPermission, pks);
258    }
259    
260    public java.util.List<UnitOfMeasureEquivalent> getEntitiesFromPKs(Session session, EntityPermission entityPermission, Collection<UnitOfMeasureEquivalentPK> pks)
261            throws PersistenceDatabaseException {
262        java.util.List<UnitOfMeasureEquivalent> _entities = new ArrayList<>(pks.size());
263        
264        for(UnitOfMeasureEquivalentPK _pk: pks) {
265            _entities.add(getEntityFromPK(session, entityPermission, _pk));
266        }
267        
268        return _entities;
269    }
270    
271    public UnitOfMeasureEquivalent getEntityFromValue(EntityPermission entityPermission, UnitOfMeasureEquivalentValue value) {
272        return getEntityFromPK(ThreadSession.currentSession(), entityPermission, value.getPrimaryKey());
273    }
274    
275    public UnitOfMeasureEquivalent getEntityFromValue(Session session, EntityPermission entityPermission, UnitOfMeasureEquivalentValue value) {
276        return getEntityFromPK(session, entityPermission, value.getPrimaryKey());
277    }
278    
279    public UnitOfMeasureEquivalent getEntityFromPK(EntityPermission entityPermission, UnitOfMeasureEquivalentPK pk)
280            throws PersistenceDatabaseException {
281        return getEntityFromPK(ThreadSession.currentSession(), entityPermission, pk);
282    }
283    
284    public UnitOfMeasureEquivalent getEntityFromCache(Session session, UnitOfMeasureEquivalentPK pk) {
285        UnitOfMeasureEquivalentValue _value = (UnitOfMeasureEquivalentValue)session.getValueCache().get(pk);
286    
287        return _value == null ? null : new UnitOfMeasureEquivalent(_value, EntityPermission.READ_ONLY);
288    }
289    
290    public UnitOfMeasureEquivalent getEntityFromPK(Session session, EntityPermission entityPermission, UnitOfMeasureEquivalentPK pk)
291            throws PersistenceDatabaseException {
292        UnitOfMeasureEquivalent _entity;
293        
294        // See if we already have the entity in the session cache
295        _entity = (UnitOfMeasureEquivalent)session.getEntity(pk);
296        if(_entity != null) {
297            // If the requested permission is READ_WRITE, and the cached permission is
298            // READ_ONLY, then pretend that the cached object wasn't found, and create
299            // a new entity that is READ_WRITE.
300            if(entityPermission.equals(EntityPermission.READ_WRITE)) {
301                if(_entity.getEntityPermission().equals(EntityPermission.READ_ONLY))
302                    _entity = null;
303            }
304        }
305        
306        if(_entity == null && entityPermission.equals(EntityPermission.READ_ONLY)) {
307            _entity = getEntityFromCache(session, pk);
308        }
309        
310        if(_entity == null) {
311            PreparedStatement _ps = session.prepareStatement(entityPermission.equals(EntityPermission.READ_ONLY)? SQL_SELECT_READ_ONLY: SQL_SELECT_READ_WRITE);
312            long _entityId = pk.getEntityId();
313            ResultSet _rs = null;
314            
315            try {
316                _ps.setLong(1, _entityId);
317                _rs = _ps.executeQuery();
318                if(_rs.next()) {
319                    _entity = getEntityFromResultSet(session, entityPermission, _rs);
320                }
321            } catch (SQLException se) {
322                throw new PersistenceDatabaseException(se);
323            } finally {
324                if(_rs != null) {
325                    try {
326                        _rs.close();
327                    } catch (SQLException se) {
328                        // do nothing
329                    }
330                }
331            }
332        }
333        
334        return _entity;
335    }
336    
337    public Set<UnitOfMeasureEquivalentPK> getPKsFromQueryAsSet(PreparedStatement ps, final Object... params)
338            throws PersistenceDatabaseException {
339        Set<UnitOfMeasureEquivalentPK> _pks;
340        ResultSet _rs = null;
341        
342        try {
343            if(params.length != 0) {
344                Session.setQueryParams(ps, params);
345            }
346            
347            _rs = ps.executeQuery();
348            _pks = getPKsFromResultSetAsSet(_rs);
349            _rs.close();
350        } catch (SQLException se) {
351            throw new PersistenceDatabaseException(se);
352        } finally {
353            if(_rs != null) {
354                try {
355                    _rs.close();
356                } catch (SQLException se) {
357                    // do nothing
358                }
359            }
360        }
361        
362        return _pks;
363    }
364    
365    public java.util.List<UnitOfMeasureEquivalentPK> getPKsFromQueryAsList(PreparedStatement ps, final Object... params)
366            throws PersistenceDatabaseException {
367        java.util.List<UnitOfMeasureEquivalentPK> _pks;
368        ResultSet _rs = null;
369        
370        try {
371            if(params.length != 0) {
372                Session.setQueryParams(ps, params);
373            }
374            
375            _rs = ps.executeQuery();
376            _pks = getPKsFromResultSetAsList(_rs);
377            _rs.close();
378        } catch (SQLException se) {
379            throw new PersistenceDatabaseException(se);
380        } finally {
381            if(_rs != null) {
382                try {
383                    _rs.close();
384                } catch (SQLException se) {
385                    // do nothing
386                }
387            }
388        }
389        
390        return _pks;
391    }
392    
393    public UnitOfMeasureEquivalentPK getPKFromQuery(PreparedStatement ps, final Object... params)
394            throws PersistenceDatabaseException {
395        UnitOfMeasureEquivalentPK _pk = null;
396        ResultSet _rs = null;
397        
398        try {
399            if(params.length != 0) {
400                Session.setQueryParams(ps, params);
401            }
402            
403            _rs = ps.executeQuery();
404            if(_rs.next()) {
405                _pk = getPKFromResultSet(_rs);
406            }
407            _rs.close();
408        } catch (SQLException se) {
409            throw new PersistenceDatabaseException(se);
410        } finally {
411            if(_rs != null) {
412                try {
413                    _rs.close();
414                } catch (SQLException se) {
415                    // do nothing
416                }
417            }
418        }
419        
420        return _pk;
421    }
422    
423    public java.util.List<UnitOfMeasureEquivalent> getEntitiesFromQuery(Session session, EntityPermission entityPermission, Map<EntityPermission, String>queryMap, final Object... params)
424            throws PersistenceDatabaseException {
425        PreparedStatement ps = session.prepareStatement(UnitOfMeasureEquivalentFactory.class, queryMap.get(entityPermission));
426        
427        return getEntitiesFromQuery(session, entityPermission, ps, params);
428    }
429    
430    public java.util.List<UnitOfMeasureEquivalent> getEntitiesFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap, final Object... params)
431            throws PersistenceDatabaseException {
432        Session session = ThreadSession.currentSession();
433        PreparedStatement ps = session.prepareStatement(UnitOfMeasureEquivalentFactory.class, queryMap.get(entityPermission));
434        
435        return getEntitiesFromQuery(session, entityPermission, ps, params);
436    }
437    
438    public java.util.List<UnitOfMeasureEquivalent> getEntitiesFromQuery(Session session, EntityPermission entityPermission, Map<EntityPermission, String>queryMap)
439            throws PersistenceDatabaseException {
440        PreparedStatement ps = session.prepareStatement(UnitOfMeasureEquivalentFactory.class, queryMap.get(entityPermission));
441        
442        return getEntitiesFromQuery(session, entityPermission, ps);
443    }
444    
445    public java.util.List<UnitOfMeasureEquivalent> getEntitiesFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap)
446            throws PersistenceDatabaseException {
447        Session session = ThreadSession.currentSession();
448        PreparedStatement ps = session.prepareStatement(UnitOfMeasureEquivalentFactory.class, queryMap.get(entityPermission));
449        
450        return getEntitiesFromQuery(session, entityPermission, ps);
451    }
452    
453    public java.util.List<UnitOfMeasureEquivalent> getEntitiesFromQuery(EntityPermission entityPermission, PreparedStatement ps)
454            throws PersistenceDatabaseException {
455        return getEntitiesFromQuery(ThreadSession.currentSession(), entityPermission, ps);
456    }
457    
458    public java.util.List<UnitOfMeasureEquivalent> getEntitiesFromQuery(EntityPermission entityPermission, PreparedStatement ps, final Object... params)
459            throws PersistenceDatabaseException {
460        return getEntitiesFromQuery(ThreadSession.currentSession(), entityPermission, ps, params);
461    }
462    
463    public java.util.List<UnitOfMeasureEquivalent> getEntitiesFromQuery(Session session, EntityPermission entityPermission, PreparedStatement ps, final Object... params)
464            throws PersistenceDatabaseException {
465        java.util.List<UnitOfMeasureEquivalent> _entities;
466        ResultSet _rs = null;
467        
468        try {
469            if(params.length != 0) {
470                Session.setQueryParams(ps, params);
471            }
472            
473            _rs = ps.executeQuery();
474            _entities = getEntitiesFromResultSet(session, entityPermission, _rs);
475            _rs.close();
476        } catch (SQLException se) {
477            throw new PersistenceDatabaseException(se);
478        } finally {
479            if(_rs != null) {
480                try {
481                    _rs.close();
482                } catch (SQLException se) {
483                    // do nothing
484                }
485            }
486        }
487        
488        return _entities;
489    }
490    
491    public UnitOfMeasureEquivalent getEntityFromQuery(Session session, EntityPermission entityPermission, Map<EntityPermission, String>queryMap, final Object... params)
492            throws PersistenceDatabaseException {
493        PreparedStatement ps = session.prepareStatement(UnitOfMeasureEquivalentFactory.class, queryMap.get(entityPermission));
494        
495        return getEntityFromQuery(session, entityPermission, ps, params);
496    }
497    
498    public UnitOfMeasureEquivalent getEntityFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap, final Object... params)
499            throws PersistenceDatabaseException {
500        Session session = ThreadSession.currentSession();
501        PreparedStatement ps = session.prepareStatement(UnitOfMeasureEquivalentFactory.class, queryMap.get(entityPermission));
502        
503        return getEntityFromQuery(session, entityPermission, ps, params);
504    }
505    
506    public UnitOfMeasureEquivalent getEntityFromQuery(Session session, EntityPermission entityPermission, Map<EntityPermission, String>queryMap)
507            throws PersistenceDatabaseException {
508        PreparedStatement ps = session.prepareStatement(UnitOfMeasureEquivalentFactory.class, queryMap.get(entityPermission));
509        
510        return getEntityFromQuery(session, entityPermission, ps);
511    }
512    
513    public UnitOfMeasureEquivalent getEntityFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap)
514            throws PersistenceDatabaseException {
515        Session session = ThreadSession.currentSession();
516        PreparedStatement ps = session.prepareStatement(UnitOfMeasureEquivalentFactory.class, queryMap.get(entityPermission));
517        
518        return getEntityFromQuery(session, entityPermission, ps);
519    }
520    
521    public UnitOfMeasureEquivalent getEntityFromQuery(EntityPermission entityPermission, PreparedStatement ps)
522            throws PersistenceDatabaseException {
523        return getEntityFromQuery(ThreadSession.currentSession(), entityPermission, ps);
524    }
525    
526    public UnitOfMeasureEquivalent getEntityFromQuery(EntityPermission entityPermission, PreparedStatement ps, final Object... params)
527            throws PersistenceDatabaseException {
528        return getEntityFromQuery(ThreadSession.currentSession(), entityPermission, ps, params);
529    }
530    
531    public UnitOfMeasureEquivalent getEntityFromQuery(Session session, EntityPermission entityPermission, PreparedStatement ps, final Object... params)
532            throws PersistenceDatabaseException {
533        UnitOfMeasureEquivalent _entity = null;
534        ResultSet _rs = null;
535        
536        try {
537            if(params.length != 0) {
538                Session.setQueryParams(ps, params);
539            }
540            
541            _rs = ps.executeQuery();
542            if(_rs.next()) {
543                _entity = getEntityFromResultSet(session, entityPermission, _rs);
544            }
545            _rs.close();
546        } catch (SQLException se) {
547            throw new PersistenceDatabaseException(se);
548        } finally {
549            if(_rs != null) {
550                try {
551                    _rs.close();
552                } catch (SQLException se) {
553                    // do nothing
554                }
555            }
556        }
557        
558        return _entity;
559    }
560    
561    public java.util.List<UnitOfMeasureEquivalent> getEntitiesFromResultSet(EntityPermission entityPermission, ResultSet rs)
562            throws PersistenceDatabaseException {
563        return getEntitiesFromResultSet(ThreadSession.currentSession(), entityPermission, rs);
564    }
565    
566    public java.util.List<UnitOfMeasureEquivalent> getEntitiesFromResultSet(Session session, EntityPermission entityPermission, ResultSet rs)
567            throws PersistenceDatabaseException {
568        java.util.List<UnitOfMeasureEquivalent> _result = new ArrayList<>();
569        
570        try {
571            while(rs.next()) {
572                _result.add(getEntityFromResultSet(session, entityPermission, rs));
573            }
574        } catch (SQLException se) {
575            throw new PersistenceDatabaseException(se);
576        }
577        
578        return _result;
579    }
580    
581    public UnitOfMeasureEquivalent getEntityFromResultSet(EntityPermission entityPermission, ResultSet rs)
582            throws PersistenceDatabaseException {
583        return getEntityFromResultSet(ThreadSession.currentSession(), entityPermission, rs);
584    }
585    
586    public UnitOfMeasureEquivalent getEntityFromResultSet(Session session, EntityPermission entityPermission, ResultSet rs)
587            throws PersistenceDatabaseException {
588        UnitOfMeasureEquivalent _entity;
589        
590        try {
591            Long uomeq_unitofmeasureequivalentid = rs.getLong(UOMEQ_UNITOFMEASUREEQUIVALENTID);
592            UnitOfMeasureEquivalentPK _pk = new UnitOfMeasureEquivalentPK(uomeq_unitofmeasureequivalentid);
593            
594            // See if we already have the entity in the session cache
595            _entity = (UnitOfMeasureEquivalent)session.getEntity(_pk);
596            if(_entity != null) {
597                // If the requested permission is READ_WRITE, and the cached permission is
598                // READ_ONLY, then pretend that the cached object wasn't found, and create
599                // a new entity that is READ_WRITE.
600                if(entityPermission.equals(EntityPermission.READ_WRITE)) {
601                    if(_entity.getEntityPermission().equals(EntityPermission.READ_ONLY))
602                        _entity = null;
603                }
604            }
605            boolean foundInSessionCache = _entity != null;
606            
607            if(_entity == null && entityPermission.equals(EntityPermission.READ_ONLY)) {
608                _entity = getEntityFromCache(session, _pk);
609            }
610            
611            if(_entity == null) {
612                Long uomeq_fromunitofmeasuretypeid = rs.getLong(UOMEQ_FROMUNITOFMEASURETYPEID);
613                if(rs.wasNull())
614                    uomeq_fromunitofmeasuretypeid = null;
615                
616                Long uomeq_tounitofmeasuretypeid = rs.getLong(UOMEQ_TOUNITOFMEASURETYPEID);
617                if(rs.wasNull())
618                    uomeq_tounitofmeasuretypeid = null;
619                
620                Long uomeq_toquantity = rs.getLong(UOMEQ_TOQUANTITY);
621                if(rs.wasNull())
622                    uomeq_toquantity = null;
623                
624                Long uomeq_fromtime = rs.getLong(UOMEQ_FROMTIME);
625                if(rs.wasNull())
626                    uomeq_fromtime = null;
627                
628                Long uomeq_thrutime = rs.getLong(UOMEQ_THRUTIME);
629                if(rs.wasNull())
630                    uomeq_thrutime = null;
631                
632                UnitOfMeasureEquivalentValue _value = new UnitOfMeasureEquivalentValue(_pk, uomeq_fromunitofmeasuretypeid == null? null: new UnitOfMeasureTypePK(uomeq_fromunitofmeasuretypeid), uomeq_tounitofmeasuretypeid == null? null: new UnitOfMeasureTypePK(uomeq_tounitofmeasuretypeid), uomeq_toquantity, uomeq_fromtime, uomeq_thrutime);
633                _entity = new UnitOfMeasureEquivalent(_value, entityPermission);
634            }
635            
636            if(!foundInSessionCache) {
637                if(entityPermission.equals(EntityPermission.READ_ONLY)) {
638                    session.putReadOnlyEntity(_pk, _entity);
639                    session.getValueCache().put(_entity.getUnitOfMeasureEquivalentValue());
640                } else {
641                    session.putReadWriteEntity(_pk, _entity);
642                }
643            }
644        } catch (SQLException se) {
645            throw new PersistenceDatabaseException(se);
646        }
647        
648        return _entity;
649    }
650    
651    public UnitOfMeasureEquivalent create(Session session, UnitOfMeasureType fromUnitOfMeasureType, UnitOfMeasureType toUnitOfMeasureType, Long toQuantity, Long fromTime, Long thruTime)
652            throws PersistenceDatabaseException, PersistenceNotNullException {
653        return create(session, fromUnitOfMeasureType == null ? null : fromUnitOfMeasureType.getPrimaryKey(), toUnitOfMeasureType == null ? null : toUnitOfMeasureType.getPrimaryKey(), toQuantity, fromTime, thruTime);
654    }
655    
656    public UnitOfMeasureEquivalent create(UnitOfMeasureType fromUnitOfMeasureType, UnitOfMeasureType toUnitOfMeasureType, Long toQuantity, Long fromTime, Long thruTime)
657            throws PersistenceDatabaseException, PersistenceNotNullException {
658        return create(ThreadSession.currentSession(), fromUnitOfMeasureType == null ? null : fromUnitOfMeasureType.getPrimaryKey(), toUnitOfMeasureType == null ? null : toUnitOfMeasureType.getPrimaryKey(), toQuantity, fromTime, thruTime);
659    }
660    
661    private void bindForCreate(PreparedStatement _ps, UnitOfMeasureEquivalentValue _value)
662            throws SQLException {
663        _ps.setLong(1, _value.getEntityId());
664        
665        UnitOfMeasureTypePK uomeq_fromunitofmeasuretypeid = _value.getFromUnitOfMeasureTypePK();
666        if(uomeq_fromunitofmeasuretypeid == null)
667            _ps.setNull(2, Types.BIGINT);
668        else
669            _ps.setLong(2, uomeq_fromunitofmeasuretypeid.getEntityId());
670            
671        UnitOfMeasureTypePK uomeq_tounitofmeasuretypeid = _value.getToUnitOfMeasureTypePK();
672        if(uomeq_tounitofmeasuretypeid == null)
673            _ps.setNull(3, Types.BIGINT);
674        else
675            _ps.setLong(3, uomeq_tounitofmeasuretypeid.getEntityId());
676            
677        Long uomeq_toquantity = _value.getToQuantity();
678        if(uomeq_toquantity == null)
679            _ps.setNull(4, Types.BIGINT);
680        else
681            _ps.setLong(4, uomeq_toquantity);
682            
683        Long uomeq_fromtime = _value.getFromTime();
684        if(uomeq_fromtime == null)
685            _ps.setNull(5, Types.BIGINT);
686        else
687            _ps.setLong(5, uomeq_fromtime);
688            
689        Long uomeq_thrutime = _value.getThruTime();
690        if(uomeq_thrutime == null)
691            _ps.setNull(6, Types.BIGINT);
692        else
693            _ps.setLong(6, uomeq_thrutime);
694            
695    }
696    
697    public UnitOfMeasureEquivalent create(Session session, UnitOfMeasureTypePK fromUnitOfMeasureTypePK, UnitOfMeasureTypePK toUnitOfMeasureTypePK, Long toQuantity, Long fromTime, Long thruTime)
698            throws PersistenceDatabaseException, PersistenceNotNullException {
699        UnitOfMeasureEquivalentPK _pk = getNextPK();
700        UnitOfMeasureEquivalentValue _value = new UnitOfMeasureEquivalentValue(_pk, fromUnitOfMeasureTypePK, toUnitOfMeasureTypePK, toQuantity, fromTime, thruTime);
701        
702        PreparedStatement _ps = session.prepareStatement(SQL_INSERT);
703        
704        try {
705            bindForCreate(_ps, _value);
706            
707            if(PersistenceDebugFlags.CheckEntityInsertRowCount) {
708                int _count = _ps.executeUpdate();
709                
710                if(_count != 1) {
711                    throw new PersistenceDatabaseUpdateException("insert failed, _count = " + _count);
712                }
713            } else {
714                 _ps.executeUpdate();
715            }
716            
717            session.getValueCache().put(_value);
718        } catch (SQLException se) {
719            throw new PersistenceDatabaseException(se);
720        }
721        
722        UnitOfMeasureEquivalent _entity = new UnitOfMeasureEquivalent(_value, EntityPermission.READ_ONLY);
723        session.putReadOnlyEntity(_pk, _entity);
724        
725        return _entity;
726    }
727    
728    public UnitOfMeasureEquivalent create(UnitOfMeasureTypePK fromUnitOfMeasureTypePK, UnitOfMeasureTypePK toUnitOfMeasureTypePK, Long toQuantity, Long fromTime, Long thruTime)
729            throws PersistenceDatabaseException, PersistenceNotNullException {
730        return create(ThreadSession.currentSession(), fromUnitOfMeasureTypePK, toUnitOfMeasureTypePK, toQuantity, fromTime, thruTime);
731    }
732    
733    public void create(Session session, Collection<UnitOfMeasureEquivalentValue> _values)
734            throws PersistenceDatabaseException, PersistenceNotNullException {
735        int _size = _values.size();
736        
737        if(_size > 0) {
738            PreparedStatement _ps = session.prepareStatement(SQL_INSERT);
739            List<UnitOfMeasureEquivalentValue> _cacheValues = new ArrayList<>(_size);
740            
741            try {
742                for(UnitOfMeasureEquivalentValue _value : _values) {
743                    _value.setEntityId(entityIdGenerator.getNextEntityId());
744                    bindForCreate(_ps, _value);
745                    
746                    _ps.addBatch();
747                    
748                    _cacheValues.add(_value);
749                }
750                
751                if(PersistenceDebugFlags.CheckEntityInsertRowCount) {
752                    int[] _counts = _ps.executeBatch();
753                    
754                    for(int _countOffset = 0 ; _countOffset < _size ; _countOffset++) {
755                        if(_counts[_countOffset] != 1 && _counts[_countOffset] != PreparedStatement.SUCCESS_NO_INFO) {
756                            throw new PersistenceDatabaseUpdateException("batch insert failed, _counts[" + _countOffset + "] = " + _counts[_countOffset]);
757                        }
758                    }
759                } else {
760                     _ps.executeBatch();
761                }
762                
763                _ps.clearBatch();
764            } catch (SQLException se) {
765                throw new PersistenceDatabaseException(se);
766            }
767            
768            _cacheValues.forEach((_cacheValue) -> {
769                UnitOfMeasureEquivalent _cacheEntity = new UnitOfMeasureEquivalent(_cacheValue, EntityPermission.READ_ONLY);
770                
771                session.putReadOnlyEntity(_cacheValue.getPrimaryKey(), _cacheEntity);
772            });
773        }
774    }
775    
776    public void create(Collection<UnitOfMeasureEquivalentValue> _values)
777            throws PersistenceDatabaseException, PersistenceNotNullException {
778        create(ThreadSession.currentSession(), _values);
779    }
780    
781    private boolean bindForStore(PreparedStatement _ps, UnitOfMeasureEquivalentValue _value)
782            throws SQLException {
783        boolean _hasBeenModified = _value.hasBeenModified();
784        
785        if(_hasBeenModified) {
786            UnitOfMeasureTypePK uomeq_fromunitofmeasuretypeid = _value.getFromUnitOfMeasureTypePK();
787            if(uomeq_fromunitofmeasuretypeid == null)
788                _ps.setNull(1, Types.BIGINT);
789            else
790                _ps.setLong(1, uomeq_fromunitofmeasuretypeid.getEntityId());
791            
792            UnitOfMeasureTypePK uomeq_tounitofmeasuretypeid = _value.getToUnitOfMeasureTypePK();
793            if(uomeq_tounitofmeasuretypeid == null)
794                _ps.setNull(2, Types.BIGINT);
795            else
796                _ps.setLong(2, uomeq_tounitofmeasuretypeid.getEntityId());
797            
798            Long uomeq_toquantity = _value.getToQuantity();
799            if(uomeq_toquantity == null)
800                _ps.setNull(3, Types.BIGINT);
801            else
802                _ps.setLong(3, uomeq_toquantity);
803            
804            Long uomeq_fromtime = _value.getFromTime();
805            if(uomeq_fromtime == null)
806                _ps.setNull(4, Types.BIGINT);
807            else
808                _ps.setLong(4, uomeq_fromtime);
809            
810            Long uomeq_thrutime = _value.getThruTime();
811            if(uomeq_thrutime == null)
812                _ps.setNull(5, Types.BIGINT);
813            else
814                _ps.setLong(5, uomeq_thrutime);
815            
816            _ps.setLong(6, _value.getPrimaryKey().getEntityId());
817            
818            _value.clearHasBeenModified();
819        }
820        
821        return _hasBeenModified;
822    }
823    
824    @Override
825    public void store(Session session, UnitOfMeasureEquivalent entity)
826            throws PersistenceDatabaseException {
827        PreparedStatement _ps = session.prepareStatement(SQL_UPDATE);
828        
829        try {
830            UnitOfMeasureEquivalentValue _value = entity.getUnitOfMeasureEquivalentValue();
831            
832            if(bindForStore(_ps, _value)) {
833                if(PersistenceDebugFlags.CheckEntityUpdateRowCount) {
834                    int _count = _ps.executeUpdate();
835                    
836                    if(_count != 1) {
837                        throw new PersistenceDatabaseUpdateException("update failed, _count = " + _count);
838                    }
839                } else {
840                     _ps.executeUpdate();
841                }
842                
843                session.getValueCache().put(_value);
844            }
845        } catch (SQLException se) {
846            throw new PersistenceDatabaseException(se);
847        }
848    }
849    
850    @Override
851    public void store(Session session, Collection<UnitOfMeasureEquivalent> entities)
852            throws PersistenceDatabaseException {
853        if(entities.size() > 0) {
854            PreparedStatement _ps = session.prepareStatement(SQL_UPDATE);
855            int _modifiedEntities = 0;
856            
857            try {
858                for(UnitOfMeasureEquivalent entity : entities) {
859                    if(bindForStore(_ps, entity.getUnitOfMeasureEquivalentValue())) {
860                        _ps.addBatch();
861                        _modifiedEntities++;
862                    }
863                }
864                
865                if(_modifiedEntities != 0) {
866                    if(PersistenceDebugFlags.CheckEntityUpdateRowCount) {
867                        int[] _counts = _ps.executeBatch();
868                        
869                        for(int _countOffset = 0 ; _countOffset < _modifiedEntities  ; _countOffset++) {
870                            if(_counts[_countOffset] != 1 && _counts[_countOffset] != PreparedStatement.SUCCESS_NO_INFO) {
871                                throw new PersistenceDatabaseUpdateException("batch update failed, _counts[" + _countOffset + "] = " + _counts[_countOffset]);
872                            }
873                        }
874                    } else {
875                         _ps.executeBatch();
876                    }
877                    
878                    _ps.clearBatch();
879                    
880                    entities.forEach((entity) -> {
881                        session.getValueCache().put(entity.getUnitOfMeasureEquivalentValue());
882                    });
883                }
884            } catch (SQLException se) {
885                throw new PersistenceDatabaseException(se);
886            }
887        }
888    }
889    
890    @Override
891    public void store(Collection<UnitOfMeasureEquivalent> entities)
892            throws PersistenceDatabaseException {
893        store(ThreadSession.currentSession(), entities);
894    }
895    
896    @Override
897    public void remove(Session session, UnitOfMeasureEquivalent entity)
898            throws PersistenceDatabaseException {
899        remove(session, entity.getPrimaryKey());
900    }
901    
902    @Override
903    public void remove(Session session, UnitOfMeasureEquivalentPK pk)
904            throws PersistenceDatabaseException {
905        PreparedStatement _ps = session.prepareStatement(SQL_DELETE);
906        long _entityId = pk.getEntityId();
907        
908        try {
909            _ps.setLong(1, _entityId);
910            
911            if(PersistenceDebugFlags.CheckEntityDeleteRowCount) {
912                int _count = _ps.executeUpdate();
913                
914                if(_count != 1) {
915                    throw new PersistenceDatabaseUpdateException("remove failed, _count = " + _count);
916                }
917            } else {
918                 _ps.executeUpdate();
919            }
920            
921            session.getValueCache().remove(pk);
922        } catch (SQLException se) {
923            throw new PersistenceDatabaseException(se);
924        }
925        
926        session.removed(pk, false);
927    }
928    
929    @Override
930    public void remove(Session session, Collection<UnitOfMeasureEquivalentPK> pks)
931            throws PersistenceDatabaseException {
932        if(pks.size() > 0) {
933            PreparedStatement _ps = session.prepareStatement(SQL_DELETE);
934            int _modifiedEntities = 0;
935            
936            try {
937                for(UnitOfMeasureEquivalentPK pk : pks) {
938                    long _entityId = pk.getEntityId();
939                    
940                    _ps.setLong(1, _entityId);
941                    
942                    _ps.addBatch();
943                    _modifiedEntities++;
944                }
945                
946                if(_modifiedEntities != 0) {
947                    if(PersistenceDebugFlags.CheckEntityDeleteRowCount) {
948                        int[] _counts = _ps.executeBatch();
949                        
950                        for(int _countOffset = 0 ; _countOffset < _modifiedEntities  ; _countOffset++) {
951                            if(_counts[_countOffset] != 1 && _counts[_countOffset] != PreparedStatement.SUCCESS_NO_INFO) {
952                                throw new PersistenceDatabaseUpdateException("batch remove failed, _counts[" + _countOffset + "] = " + _counts[_countOffset]);
953                            }
954                        }
955                    } else {
956                        _ps.executeBatch();
957                    }
958                    
959                    _ps.clearBatch();
960                    
961                    pks.forEach((pk) -> {
962                        session.getValueCache().remove(pk);
963                    });
964                }
965            } catch (SQLException se) {
966                throw new PersistenceDatabaseException(se);
967            }
968            
969            pks.forEach((pk) -> {
970                session.removed(pk, true);
971            });
972        }
973    }
974    
975    @Override
976    public void remove(Collection<UnitOfMeasureEquivalentPK> pks)
977            throws PersistenceDatabaseException {
978        remove(ThreadSession.currentSession(), pks);
979    }
980    
981    @Override
982    public boolean validPK(Session session, UnitOfMeasureEquivalentPK pk)
983            throws PersistenceDatabaseException {
984        boolean valid = false;
985        PreparedStatement _ps = session.prepareStatement(SQL_VALID);
986        ResultSet _rs = null;
987        
988        try {
989            _ps.setLong(1, pk.getEntityId());
990            
991            _rs = _ps.executeQuery();
992            if(_rs.next()) {
993                long _count = _rs.getLong(1);
994                if(_rs.wasNull())
995                    _count = 0;
996                
997                if(_count == 1)
998                    valid = true;
999            }
1000        } catch (SQLException se) {
1001            throw new PersistenceDatabaseException(se);
1002        } finally {
1003            if(_rs != null) {
1004                try {
1005                    _rs.close();
1006                } catch (SQLException se) {
1007                    // do nothing
1008                }
1009            }
1010        }
1011        
1012        return valid;
1013    }
1014    
1015}