Updates has_indexing_properties field for given Item

@param int $itemUid
@param bool $hasIndexingPropertiesFlag
@return int number of affected rows, 1 on success
486366
public function updateHasIndexingPropertiesFlagByItemUid(int $itemUid, bool $hasIndexingPropertiesFlag): int
    {
        $queryBuilder = $this->getQueryBuilder();

        return $queryBuilder
            ->update($this->table)
            ->where($queryBuilder->expr()->eq('uid', $queryBuilder->createNamedParameter($itemUid, \PDO::PARAM_INT)))
            ->set('has_indexing_properties', $queryBuilder->createNamedParameter($hasIndexingPropertiesFlag, \PDO::PARAM_INT), false)
            ->execute();
    }
1156133
def has_property(self, property_name):
        
        if property_name in self.properties:
            return True
        elif property_name in self.entities:
            return True
        elif property_name in self.collections:
            return True
        else:
            return False
1259572
public static function update($itemid, $newvalue) {
        global $DB;
        require_capability('moodle/tag:manage', context_system::instance());
        $tagarea = $DB->get_record('tag_area', array('id' => $itemid), '*', MUST_EXIST);
        $newvalue = $newvalue ? 1 : 0;
        $data = array('enabled' => $newvalue);
        \core_tag_area::update($tagarea, $data);
        $tagarea->enabled = $newvalue;
        $tmpl = new self($tagarea);
        return $tmpl;
    }
1066499
public String addDateDocumentWithId(String indexName, String indexType, Object bean,Object docId) throws ElasticSearchException{
		return addDocumentWithId(this.indexNameBuilder.getIndexName(indexName),   indexType,     bean,docId);
	}
586379
public function containsItemWithRootPageId(string $itemType, int $itemUid, int $rootPageId) : bool
    {
        $queryBuilder = $this->getQueryBuilderForContainsMethods($itemType, $itemUid);
        return (bool)$queryBuilder
            ->andWhere($queryBuilder->expr()->eq('root', $rootPageId))
            ->execute()->fetchColumn(0);
    }
145110
protected boolean isIncludedInNodeIndex(InternalQName propertyName)
   {
      if (indexingConfig == null)
      {
         return true;
      }
      else
      {
         return indexingConfig.isIncludedInNodeScopeIndex(node, propertyName);
      }
   }
881958
public function createIndex(
        IndexUUID $indexUUID,
        Config $config
    ) {
        if (array_key_exists($this->getIndexKey($indexUUID), $this->indices)) {
            throw ResourceExistsException::indexExists();
        }

        $this->indices[$this->getIndexKey($indexUUID)] = [
            'config' => $config,
            'was_reset' => false,
            'was_reconfigured' => false,
        ];
    }
557961
public function hasItem(string $cacheId, bool $withVersion = true) : bool
    {
        if ($withVersion) {
            $cacheId .= '.' . $this->getVersion();
        }

        return $this->cache->has($cacheId);
    }
410414
private function getMatchingIndexes($fromField, array $matchingList, PreferenceInterface $clientPref)
    {
        $matchingIndexList = array();

        foreach ($matchingList as $key => $matching) {
            if ($this->partialLangMatches($fromField, $matching, $clientPref)) {
                $matchingIndexList[] = $key;
            }
        }

        return $matchingIndexList;
    }
424287
protected function addIndex(&$property, Index $index)
    {
        $property .= sprintf("('%s')", $this->getPropertyBase($index->getType), $index->name);

        return $this->addFieldPropertyClousure($property);
    }
922099
private void countCoordinates(int xCoord, int yCoord,
			ItemDocument itemDocument) {

		for (String siteKey : itemDocument.getSiteLinks().keySet()) {
			Integer count = this.siteCounts.get(siteKey);
			if (count == null) {
				this.siteCounts.put(siteKey, 1);
			} else {
				this.siteCounts.put(siteKey, count + 1);
			}
		}

		for (ValueMap vm : this.valueMaps) {
			vm.countCoordinates(xCoord, yCoord, itemDocument);
		}
	}
956289
@Override
	public boolean isReadonly() {

		if (isIdProperty() || isVersionProperty()) {
			return false;
		}

		Indexed indexedAnnotation = getIndexAnnotation();
		if (indexedAnnotation != null && indexedAnnotation.readonly()) {
			return true;
		}
		if (indexedAnnotation == null && getFieldAnnotation() == null) {
			return true;
		}
		return false;
	}
68835
private function setDataForItem($itemId, $tags, $thisExisting)
    {
        if ($tags === null) {
            $tagIds = [];
        } else {
            $tagIds = \array_keys($tags);
        }

        // First pass, delete all not mentioned anymore.
        $valuesToRemove = \array_diff($thisExisting, $tagIds);
        if ($valuesToRemove) {
            $this->connection
                ->createQueryBuilder()
                ->delete('tl_metamodel_tag_relation')
                ->where('att_id=:attId')
                ->andWhere('item_id=:itemId')
                ->andWhere('value_id IN (:valueIds)')
                ->setParameter('attId', $this->get('id'))
                ->setParameter('itemId', $itemId)
                ->setParameter('valueIds', $valuesToRemove, Connection::PARAM_STR_ARRAY)
                ->execute();
        }

        // Second pass, add all new values in a row.
        $valuesToAdd  = \array_diff($tagIds, $thisExisting);
        $insertValues = [];
        if ($valuesToAdd) {
            foreach ($valuesToAdd as $valueId) {
                $insertValues[] = [
                    'attId'   => $this->get('id'),
                    'itemId'  => $itemId,
                    'sorting' => (int) $tags[$valueId]['tag_value_sorting'],
                    'valueId' => $valueId
                ];
            }
        }

        // Third pass, update all sorting values.
        $valuesToUpdate = \array_diff($tagIds, $valuesToAdd);
        if ($valuesToUpdate) {
            $query = $this->connection
                ->createQueryBuilder()
                ->update('tl_metamodel_tag_relation')
                ->set('value_sorting', ':sorting')
                ->where('att_id=:attId')
                ->andWhere('item_id=:itemId')
                ->andWhere('value_id=:valueId')
                ->setParameter('attId', $this->get('id'))
                ->setParameter('itemId', $itemId);

            foreach ($valuesToUpdate as $valueId) {
                if (!array_key_exists('tag_value_sorting', $tags[$valueId])) {
                    continue;
                }
                $query
                    ->setParameter('sorting', (int) $tags[$valueId]['tag_value_sorting'])
                    ->setParameter('valueId', $valueId)
                    ->execute();
            }
        }

        return $insertValues;
    }
239614
public static MozuUrl updateExtendedPropertiesUrl(Boolean upsert)
	{
		UrlFormatter formatter = new UrlFormatter("/api/commerce/carts/current/extendedproperties?upsert={upsert}");
		formatter.formatUrl("upsert", upsert);
		return new MozuUrl(formatter.getResourceUrl(), MozuUrl.UrlLocation.TENANT_POD) ;
	}
1219063
public static boolean hasProperty(ClassNode classNode, String propertyName) {
        if (classNode == null || !StringUtils.hasText(propertyName)) {
            return false;
        }

        final MethodNode method = classNode.getMethod(GrailsNameUtils.getGetterName(propertyName), Parameter.EMPTY_ARRAY);
        if (method != null) return true;

        // check read-only field with setter
        if( classNode.getField(propertyName) != null && !classNode.getMethods(GrailsNameUtils.getSetterName(propertyName)).isEmpty()) {
            return true;
        }

        for (PropertyNode pn : classNode.getProperties()) {
            if (pn.getName().equals(propertyName) && !pn.isPrivate()) {
                return true;
            }
        }

        return false;
    }
445649
public void indexDocument(String indexName, String mappingName, String id, XContentBuilder document)
            throws Exception {
        client.prepareIndex(indexName, mappingName, id).setSource(document).get();
    }
14321
protected void updateIssueManagement(IssueManagement value, String xmlTag, Counter counter, Element element)
   {
      boolean shouldExist = value != null;
      Element root = updateElement(counter, element, xmlTag, shouldExist);
      if (shouldExist)
      {
         Counter innerCount = new Counter(counter.getDepth() + 1);
         findAndReplaceSimpleElement(innerCount, root, "system", value.getSystem(), null);
         findAndReplaceSimpleElement(innerCount, root, "url", value.getUrl(), null);
      }
   }