Source code

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