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