Source code

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