3 +--------------------------------------------------------------------+
4 | CiviCRM version 4.7 |
5 +--------------------------------------------------------------------+
6 | Copyright CiviCRM LLC (c) 2004-2016 |
7 +--------------------------------------------------------------------+
8 | This file is a part of CiviCRM. |
10 | CiviCRM is free software; you can copy, modify, and distribute it |
11 | under the terms of the GNU Affero General Public License |
12 | Version 3, 19 November 2007 and the CiviCRM Licensing Exception. |
14 | CiviCRM is distributed in the hope that it will be useful, but |
15 | WITHOUT ANY WARRANTY; without even the implied warranty of |
16 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
17 | See the GNU Affero General Public License for more details. |
19 | You should have received a copy of the GNU Affero General Public |
20 | License and the CiviCRM Licensing Exception along |
21 | with this program; if not, contact CiviCRM LLC |
22 | at info[AT]civicrm[DOT]org. If you have questions about the |
23 | GNU Affero General Public License or the licensing of CiviCRM, |
24 | see the CiviCRM license FAQ at http://civicrm.org/licensing |
25 +--------------------------------------------------------------------+
31 * @copyright CiviCRM LLC (c) 2004-2016
33 class CRM_Contact_BAO_GroupContactCache
extends CRM_Contact_DAO_GroupContactCache
{
35 static $_alreadyLoaded = array();
38 * Get a list of caching modes.
42 public static function getModes() {
44 // Flush expired caches in response to user actions.
45 'opportunistic' => ts('Opportunistic Flush'),
47 // Flush expired caches via background cron jobs.
48 'deterministic' => ts('Cron Flush'),
53 * Check to see if we have cache entries for this group.
55 * If not, regenerate, else return.
57 * @param array $groupIDs
58 * Of group that we are checking against.
61 * TRUE if we did not regenerate, FALSE if we did
63 public static function check($groupIDs) {
64 if (empty($groupIDs)) {
68 return self
::loadAll($groupIDs);
72 * Formulate the query to see which groups needs to be refreshed.
74 * The calculation is based on their cache date and the smartGroupCacheTimeOut
76 * @param string $groupIDClause
77 * The clause which limits which groups we need to evaluate.
78 * @param bool $includeHiddenGroups
79 * Hidden groups are excluded by default.
82 * the sql query which lists the groups that need to be refreshed
84 public static function groupRefreshedClause($groupIDClause = NULL, $includeHiddenGroups = FALSE) {
85 $smartGroupCacheTimeoutDateTime = self
::getCacheInvalidDateTime();
90 WHERE ( g.saved_search_id IS NOT NULL OR g.children IS NOT NULL )
94 OR cache_date <= $smartGroupCacheTimeoutDateTime
95 OR NOW() >= g.refresh_date
98 if (!$includeHiddenGroups) {
99 $query .= "AND (g.is_hidden = 0 OR g.is_hidden IS NULL)";
102 if (!empty($groupIDClause)) {
103 $query .= " AND ( $groupIDClause ) ";
110 * Check to see if a group has been refreshed recently.
112 * This is primarily used in a locking scenario when some other process might have refreshed things underneath
115 * @param int $groupID
117 * @param bool $includeHiddenGroups
118 * Hidden groups are excluded by default.
121 * the sql query which lists the groups that need to be refreshed
123 public static function shouldGroupBeRefreshed($groupID, $includeHiddenGroups = FALSE) {
124 $query = self
::groupRefreshedClause("g.id = %1", $includeHiddenGroups);
125 $params = array(1 => array($groupID, 'Integer'));
127 // if the query returns the group ID, it means the group is a valid candidate for refreshing
128 return CRM_Core_DAO
::singleValueQuery($query, $params);
132 * Check to see if we have cache entries for this group.
134 * if not, regenerate, else return
136 * @param int|array $groupIDs groupIDs of group that we are checking against
137 * if empty, all groups are checked
139 * Limits the number of groups we evaluate.
142 * TRUE if we did not regenerate, FALSE if we did
144 public static function loadAll($groupIDs = NULL, $limit = 0) {
145 // ensure that all the smart groups are loaded
146 // this function is expensive and should be sparingly used if groupIDs is empty
147 if (empty($groupIDs)) {
148 $groupIDClause = NULL;
152 if (!is_array($groupIDs)) {
153 $groupIDs = array($groupIDs);
156 // note escapeString is a must here and we can't send the imploded value as second argument to
157 // the executeQuery(), since that would put single quote around the string and such a string
158 // of comma separated integers would not work.
159 $groupIDString = CRM_Core_DAO
::escapeString(implode(', ', $groupIDs));
161 $groupIDClause = "g.id IN ({$groupIDString})";
164 $query = self
::groupRefreshedClause($groupIDClause);
166 $limitClause = $orderClause = NULL;
168 $limitClause = " LIMIT 0, $limit";
169 $orderClause = " ORDER BY g.cache_date, g.refresh_date";
171 // We ignore hidden groups and disabled groups
177 $dao = CRM_Core_DAO
::executeQuery($query);
178 $processGroupIDs = array();
179 $refreshGroupIDs = $groupIDs;
180 while ($dao->fetch()) {
181 $processGroupIDs[] = $dao->id
;
183 // remove this id from refreshGroupIDs
184 foreach ($refreshGroupIDs as $idx => $gid) {
185 if ($gid == $dao->id
) {
186 unset($refreshGroupIDs[$idx]);
192 if (!empty($refreshGroupIDs)) {
193 $refreshGroupIDString = CRM_Core_DAO
::escapeString(implode(', ', $refreshGroupIDs));
194 $time = self
::getRefreshDateTime();
196 UPDATE civicrm_group g
197 SET g.refresh_date = $time
198 WHERE g.id IN ( {$refreshGroupIDString} )
199 AND g.refresh_date IS NULL
201 CRM_Core_DAO
::executeQuery($query);
204 if (empty($processGroupIDs)) {
208 self
::add($processGroupIDs);
214 * Fill the group contact cache if it is empty.
216 * Do this by the expensive operation of loading all groups. Call sparingly.
218 public static function fillIfEmpty() {
219 if (!CRM_Core_DAO
::singleValueQuery("SELECT COUNT(id) FROM civicrm_group_contact_cache")) {
225 * Build the smart group cache for a given group.
227 * @param int $groupID
229 public static function add($groupID) {
230 // first delete the current cache
231 self
::remove($groupID);
232 if (!is_array($groupID)) {
233 $groupID = array($groupID);
236 $returnProperties = array('contact_id');
237 foreach ($groupID as $gid) {
238 $params = array(array('group', 'IN', array($gid), 0, 0));
239 // the below call updates the cache table as a byproduct of the query
240 CRM_Contact_BAO_Query
::apiQuery($params, $returnProperties, NULL, NULL, 0, 0, FALSE);
245 * Store values into the group contact cache.
247 * @todo review use of INSERT IGNORE. This function appears to be slower that inserting
248 * with a left join. Also, 200 at once seems too little.
250 * @param int $groupID
251 * @param array $values
253 public static function store(&$groupID, &$values) {
256 // sort the values so we put group IDs in front and hence optimize
257 // mysql storage (or so we think) CRM-9493
260 // to avoid long strings, lets do BULK_INSERT_COUNT values at a time
261 while (!empty($values)) {
263 $input = array_splice($values, 0, CRM_Core_DAO
::BULK_INSERT_COUNT
);
264 $str = implode(',', $input);
265 $sql = "INSERT IGNORE INTO civicrm_group_contact_cache (group_id,contact_id) VALUES $str;";
266 CRM_Core_DAO
::executeQuery($sql);
268 self
::updateCacheTime($groupID, $processed);
272 * Change the cache_date.
274 * @param array $groupID
275 * @param bool $processed
276 * Whether the cache data was recently modified.
278 public static function updateCacheTime($groupID, $processed) {
279 // only update cache entry if we had any values
281 // also update the group with cache date information
282 $now = date('YmdHis');
290 $groupIDs = implode(',', $groupID);
293 SET cache_date = $now, refresh_date = $refresh
294 WHERE id IN ( $groupIDs )
296 CRM_Core_DAO
::executeQuery($sql);
300 * Removes all the cache entries pertaining to a specific group.
302 * If no groupID is passed in, removes cache entries for all groups
303 * Has an optimization to bypass repeated invocations of this function.
304 * Note that this function is an advisory, i.e. the removal respects the
305 * cache date, i.e. the removal is not done if the group was recently
306 * loaded into the cache.
308 * In fact it turned out there is little overlap between the code when group is passed in
309 * and group is not so it makes more sense as separate functions.
311 * @todo remove last call to this function from outside the class then make function protected,
312 * enforce groupID as an array & remove non group handling.
314 * @param int $groupID
315 * the groupID to delete cache entries, NULL for all groups.
316 * @param bool $onceOnly
317 * run the function exactly once for all groups.
319 public static function remove($groupID = NULL, $onceOnly = TRUE) {
320 static $invoked = FALSE;
322 // typically this needs to happy only once per instance
323 // this is especially TRUE in import, where we don't need
324 // to do this all the time
325 // this optimization is done only when no groupID is passed
326 // i.e. cache is reset for all groups
335 if ($groupID == NULL) {
338 elseif (is_array($groupID)) {
339 foreach ($groupID as $gid) {
340 unset(self
::$_alreadyLoaded[$gid]);
343 elseif ($groupID && array_key_exists($groupID, self
::$_alreadyLoaded)) {
344 unset(self
::$_alreadyLoaded[$groupID]);
348 $smartGroupCacheTimeout = self
::smartGroupCacheTimeout();
350 1 => array(self
::getCacheInvalidDateTime(), 'String'),
351 2 => array(self
::getRefreshDateTime(), 'String'),
354 if (!isset($groupID)) {
355 if ($smartGroupCacheTimeout == 0) {
357 TRUNCATE civicrm_group_contact_cache
360 UPDATE civicrm_group g
361 SET cache_date = null,
369 FROM civicrm_group_contact_cache gc
370 INNER JOIN civicrm_group g ON g.id = gc.group_id
371 WHERE g.cache_date <= %1
374 UPDATE civicrm_group g
375 SET cache_date = null,
377 WHERE g.cache_date <= %1
380 UPDATE civicrm_group g
381 SET refresh_date = %2
382 WHERE g.cache_date < %1
383 AND refresh_date IS NULL
387 elseif (is_array($groupID)) {
388 $groupIDs = implode(', ', $groupID);
391 FROM civicrm_group_contact_cache g
392 WHERE g.group_id IN ( $groupIDs )
395 UPDATE civicrm_group g
396 SET cache_date = null,
398 WHERE id IN ( $groupIDs )
404 FROM civicrm_group_contact_cache g
405 WHERE g.group_id = %1
408 UPDATE civicrm_group g
409 SET cache_date = null,
413 $params = array(1 => array($groupID, 'Integer'));
416 CRM_Core_DAO
::executeQuery($query, $params);
419 CRM_Core_DAO
::executeQuery($refresh, $params);
422 // also update the cache_date for these groups
423 CRM_Core_DAO
::executeQuery($update, $params);
427 * Refresh the smart group cache tables.
429 * This involves clearing out any aged entries (based on the site timeout setting) and resetting the time outs.
431 * This function should be called via the opportunistic or deterministic cache refresh function to make the intent
434 protected static function flushCaches() {
436 $lock = self
::getLockForRefresh();
438 catch (CRM_Core_Exception
$e) {
439 // Someone else is kindly doing the refresh for us right now.
442 $params = array(1 => array(self
::getCacheInvalidDateTime(), 'String'));
443 // @todo this is consistent with previous behaviour but as the first query could take several seconds the second
444 // could become inaccurate. It seems to make more sense to fetch them first & delete from an array (which would
445 // also reduce joins). If we do this we should also consider how best to iterate the groups. If we do them one at
446 // a time we could call a hook, allowing people to manage the frequency on their groups, or possibly custom searches
447 // might do that too. However, for 2000 groups that's 2000 iterations. If we do all once we potentially create a
448 // slow query. It's worth noting the speed issue generally relates to the size of the group but if one slow group
449 // is in a query with 500 fast ones all 500 get locked. One approach might be to calculate group size or the
450 // number of groups & then process all at once or many query runs depending on what is found. Of course those
451 // preliminary queries would need speed testing.
452 CRM_Core_DAO
::executeQuery(
455 FROM civicrm_group_contact_cache gc
456 INNER JOIN civicrm_group g ON g.id = gc.group_id
457 WHERE g.cache_date <= %1
462 // Clear these out without resetting them because we are not building caches here, only clearing them,
463 // so the state is 'as if they had never been built'.
464 CRM_Core_DAO
::executeQuery(
466 UPDATE civicrm_group g
467 SET cache_date = NULL,
469 WHERE g.cache_date <= %1
477 * Check if the refresh is already initiated.
479 * We have 2 imperfect methods for this:
480 * 1) a static variable in the function. This works fine within a request
481 * 2) a mysql lock. This works fine as long as CiviMail is not running, or if mysql is version 5.7+
483 * Where these 2 locks fail we get 2 processes running at the same time, but we have at least minimised that.
485 * @return \Civi\Core\Lock\LockInterface
486 * @throws \CRM_Core_Exception
488 protected static function getLockForRefresh() {
489 if (!isset(Civi
::$statics[__CLASS__
])) {
490 Civi
::$statics[__CLASS__
] = array('is_refresh_init' => FALSE);
493 if (Civi
::$statics[__CLASS__
]['is_refresh_init']) {
494 throw new CRM_Core_Exception('A refresh has already run in this process');
496 $lock = Civi
::lockManager()->acquire('data.core.group.refresh');
497 if ($lock->isAcquired()) {
498 Civi
::$statics[__CLASS__
]['is_refresh_init'] = TRUE;
501 throw new CRM_Core_Exception('Mysql lock unavailable');
505 * Do an opportunistic cache refresh if the site is configured for these.
507 * Sites that do not run the smart group clearing cron job should refresh the caches under an opportunistic mode, akin
508 * to a poor man's cron. The user session will be forced to wait on this so it is less desirable.
510 public static function opportunisticCacheFlush() {
511 if (Civi
::settings()->get('smart_group_cache_refresh_mode') == 'opportunistic') {
517 * Do a forced cache refresh.
519 * This function is appropriate to be called by system jobs & non-user sessions.
521 public static function deterministicCacheFlush() {
522 if (self
::smartGroupCacheTimeout() == 0) {
523 CRM_Core_DAO
::executeQuery("TRUNCATE civicrm_group_contact_cache");
524 CRM_Core_DAO
::executeQuery("
525 UPDATE civicrm_group g
526 SET cache_date = null, refresh_date = null");
534 * Remove one or more contacts from the smart group cache.
536 * @param int|array $cid
537 * @param int $groupId
540 * TRUE if successful.
542 public static function removeContact($cid, $groupId = NULL) {
545 foreach ((array) $cid as $c) {
546 $cids[] = CRM_Utils_Type
::escape($c, 'Integer');
549 $condition = count($cids) == 1 ?
"= {$cids[0]}" : "IN (" . implode(',', $cids) . ")";
551 $condition .= " AND group_id = " . CRM_Utils_Type
::escape($groupId, 'Integer');
553 $sql = "DELETE FROM civicrm_group_contact_cache WHERE contact_id $condition";
554 CRM_Core_DAO
::executeQuery($sql);
561 * Load the smart group cache for a saved search.
563 * @param object $group
564 * The smart group that needs to be loaded.
566 * Should we force a search through.
568 public static function load(&$group, $force = FALSE) {
569 $groupID = $group->id
;
570 $savedSearchID = $group->saved_search_id
;
571 if (array_key_exists($groupID, self
::$_alreadyLoaded) && !$force) {
575 // grab a lock so other processes don't compete and do the same query
576 $lock = Civi
::lockManager()->acquire("data.core.group.{$groupID}");
577 if (!$lock->isAcquired()) {
578 // this can cause inconsistent results since we don't know if the other process
579 // will fill up the cache before our calling routine needs it.
580 // however this routine does not return the status either, so basically
581 // its a "lets return and hope for the best"
585 self
::$_alreadyLoaded[$groupID] = 1;
587 // we now have the lock, but some other process could have actually done the work
588 // before we got here, so before we do any work, lets ensure that work needs to be
590 // we allow hidden groups here since we dont know if the caller wants to evaluate an
592 if (!$force && !self
::shouldGroupBeRefreshed($groupID, TRUE)) {
600 if ($savedSearchID) {
601 $ssParams = CRM_Contact_BAO_SavedSearch
::getSearchParams($savedSearchID);
603 // rectify params to what proximity search expects if there is a value for prox_distance
605 if (!empty($ssParams)) {
606 CRM_Contact_BAO_ProximityQuery
::fixInputParams($ssParams);
609 $returnProperties = array();
610 if (CRM_Core_DAO
::getFieldValue('CRM_Contact_DAO_SavedSearch', $savedSearchID, 'mapping_id')) {
611 $fv = CRM_Contact_BAO_SavedSearch
::getFormValues($savedSearchID);
612 $returnProperties = CRM_Core_BAO_Mapping
::returnProperties($fv);
615 if (isset($ssParams['customSearchID'])) {
618 // we split it up and store custom class
619 // so temp tables are not destroyed if they are used
620 // hence customClass is defined above at top of function
621 $customClass = CRM_Contact_BAO_SearchCustom
::customClass($ssParams['customSearchID'], $savedSearchID);
622 $searchSQL = $customClass->contactIDs();
623 $searchSQL = str_replace('ORDER BY contact_a.id ASC', '', $searchSQL);
624 if (!strstr($searchSQL, 'WHERE')) {
625 $searchSQL .= " WHERE ( 1 ) ";
627 $idName = 'contact_id';
630 $formValues = CRM_Contact_BAO_SavedSearch
::getFormValues($savedSearchID);
631 // CRM-17075 using the formValues in this way imposes extra logic and complexity.
632 // we have the where_clause and where tables stored in the saved_search table
633 // and should use these rather than re-processing the form criteria (which over-works
634 // the link between the form layer & the query layer too).
635 // It's hard to think of when you would want to use anything other than return
636 // properties = array('contact_id' => 1) here as the point would appear to be to
637 // generate the list of contact ids in the group.
638 // @todo review this to use values in saved_search table (preferably for 4.8).
640 = new CRM_Contact_BAO_Query(
641 $ssParams, $returnProperties, NULL,
645 CRM_Utils_Array
::value('display_relationship_type', $formValues),
646 CRM_Utils_Array
::value('operator', $formValues, 'AND')
648 $query->_useDistinct
= FALSE;
649 $query->_useGroupBy
= FALSE;
651 = $query->searchQuery(
660 $groupID = CRM_Utils_Type
::escape($groupID, 'Integer');
661 $sql = $searchSQL . " AND contact_a.id NOT IN (
662 SELECT contact_id FROM civicrm_group_contact
663 WHERE civicrm_group_contact.status = 'Removed'
664 AND civicrm_group_contact.group_id = $groupID ) ";
668 $sql = preg_replace("/^\s*SELECT/", "SELECT $groupID as group_id, ", $sql);
671 // lets also store the records that are explicitly added to the group
672 // this allows us to skip the group contact LEFT JOIN
674 SELECT $groupID as group_id, contact_id as $idName
675 FROM civicrm_group_contact
676 WHERE civicrm_group_contact.status = 'Added'
677 AND civicrm_group_contact.group_id = $groupID ";
679 $groupIDs = array($groupID);
680 self
::remove($groupIDs);
682 $tempTable = 'civicrm_temp_group_contact_cache' . rand(0, 2000);
683 foreach (array($sql, $sqlB) as $selectSql) {
687 $insertSql = "CREATE TEMPORARY TABLE $tempTable ($selectSql);";
689 CRM_Core_DAO
::executeQuery($insertSql);
690 CRM_Core_DAO
::executeQuery(
691 "INSERT IGNORE INTO civicrm_group_contact_cache (contact_id, group_id)
692 SELECT DISTINCT $idName, group_id FROM $tempTable
694 CRM_Core_DAO
::executeQuery(" DROP TEMPORARY TABLE $tempTable");
697 self
::updateCacheTime($groupIDs, $processed);
699 if ($group->children
) {
701 //Store a list of contacts who are removed from the parent group
704 FROM civicrm_group_contact
705 WHERE civicrm_group_contact.status = 'Removed'
706 AND civicrm_group_contact.group_id = $groupID ";
707 $dao = CRM_Core_DAO
::executeQuery($sql);
708 $removed_contacts = array();
709 while ($dao->fetch()) {
710 $removed_contacts[] = $dao->contact_id
;
713 $childrenIDs = explode(',', $group->children
);
714 foreach ($childrenIDs as $childID) {
715 $contactIDs = CRM_Contact_BAO_Group
::getMember($childID, FALSE);
716 //Unset each contact that is removed from the parent group
717 foreach ($removed_contacts as $removed_contact) {
718 unset($contactIDs[$removed_contact]);
721 foreach ($contactIDs as $contactID => $dontCare) {
722 $values[] = "({$groupID},{$contactID})";
725 self
::store($groupIDs, $values);
733 * Retrieve the smart group cache timeout in minutes.
735 * This checks if a timeout has been configured. If one has then smart groups should not
736 * be refreshed more frequently than the time out. If a group was recently refreshed it should not
737 * refresh again within that period.
741 public static function smartGroupCacheTimeout() {
742 $config = CRM_Core_Config
::singleton();
745 isset($config->smartGroupCacheTimeout
) &&
746 is_numeric($config->smartGroupCacheTimeout
)
748 return $config->smartGroupCacheTimeout
;
751 // Default to 5 minutes.
756 * Get all the smart groups that this contact belongs to.
758 * Note that this could potentially be a super slow function since
759 * it ensure that all contact groups are loaded in the cache
761 * @param int $contactID
762 * @param bool $showHidden
763 * Hidden groups are shown only if this flag is set.
766 * an array of groups that this contact belongs to
768 public static function contactGroup($contactID, $showHidden = FALSE) {
769 if (empty($contactID)) {
773 if (is_array($contactID)) {
774 $contactIDs = $contactID;
777 $contactIDs = array($contactID);
784 $hiddenClause = ' AND (g.is_hidden = 0 OR g.is_hidden IS NULL) ';
787 $contactIDString = CRM_Core_DAO
::escapeString(implode(', ', $contactIDs));
789 SELECT gc.group_id, gc.contact_id, g.title, g.children, g.description
790 FROM civicrm_group_contact_cache gc
791 INNER JOIN civicrm_group g ON g.id = gc.group_id
792 WHERE gc.contact_id IN ($contactIDString)
794 ORDER BY gc.contact_id, g.children
797 $dao = CRM_Core_DAO
::executeQuery($sql);
798 $contactGroup = array();
799 $prevContactID = NULL;
800 while ($dao->fetch()) {
803 $prevContactID != $dao->contact_id
805 $contactGroup[$prevContactID]['groupTitle'] = implode(', ', $contactGroup[$prevContactID]['groupTitle']);
807 $prevContactID = $dao->contact_id
;
808 if (!array_key_exists($dao->contact_id
, $contactGroup)) {
809 $contactGroup[$dao->contact_id
]
810 = array('group' => array(), 'groupTitle' => array());
813 $contactGroup[$dao->contact_id
]['group'][]
815 'id' => $dao->group_id
,
816 'title' => $dao->title
,
817 'description' => $dao->description
,
818 'children' => $dao->children
,
820 $contactGroup[$dao->contact_id
]['groupTitle'][] = $dao->title
;
823 if ($prevContactID) {
824 $contactGroup[$prevContactID]['groupTitle'] = implode(', ', $contactGroup[$prevContactID]['groupTitle']);
827 if ((!empty($contactGroup[$contactID]) && is_numeric($contactID))) {
828 return $contactGroup[$contactID];
831 return $contactGroup;
836 * Get the datetime from which the cache should be considered invalid.
838 * Ie if the smartgroup cache timeout is 5 minutes ago then the cache is invalid if it was
839 * refreshed 6 minutes ago, but not if it was refreshed 4 minutes ago.
843 public static function getCacheInvalidDateTime() {
844 return date('YmdHis', strtotime("-" . self
::smartGroupCacheTimeout() . " Minutes"));
848 * Get the date when the cache should be refreshed from.
850 * Ie. now + the offset & we will delete anything prior to then.
854 public static function getRefreshDateTime() {
855 return date('YmdHis', strtotime("+ " . self
::smartGroupCacheTimeout() . " Minutes"));