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