Counts additional occurrences of a property as qualifier property of
statements.

@param usageStatistics
statistics object where count is stored
@param property
the property to count
@param count
the number of times to count the property
543046
private void countPropertyQualifier(UsageStatistics usageStatistics,
			PropertyIdValue property, int count) {
		addPropertyCounters(usageStatistics, property);
		usageStatistics.propertyCountsQualifier.put(property,
				usageStatistics.propertyCountsQualifier.get(property) + count);
	}
585887
public int deleteProperty(String property) {
		int count = 0;
		if (has()) {
			TDao dao = getDao();
			String where = dao.buildWhere(COLUMN_PROPERTY, property);
			String[] whereArgs = dao.buildWhereArgs(property);
			count = dao.delete(where, whereArgs);
		}
		return count;
	}
445548
public org.grails.datastore.mapping.query.api.ProjectionList sum(String propertyName, String alias) {
        final AggregateProjection proj = Projections.sum(calculatePropertyName(propertyName));
        addProjectionToList(proj, alias);
        return this;
    }
1352711
protected void addEqualsCondition(final Expression<String> property, final String value) {
        fieldConditions.add(getCriteriaBuilder().equal(property, value));
    }
316225
public GlobalJmxStatisticsConfigurationBuilder withProperties(Properties properties) {
      attributes.attribute(PROPERTIES).set(new TypedProperties(properties));
      return this;
   }
748712
public synchronized SamplerResult<T> finishSampling(int count)
    {
        List<Counter<T>> results = Collections.EMPTY_LIST;
        long cardinality = 0;
        if (enabled)
        {
            enabled = false;
            results = summary.topK(count);
            cardinality = hll.cardinality();
        }
        return new SamplerResult<T>(results, cardinality);
    }
222466
private void declareProperty(ExecutionContextProperty property)
    {
        if (this.properties.containsKey(property.getKey())) {
            throw new PropertyAlreadyExistsException(property.getKey());
        }

        this.properties.put(property.getKey(), property);
    }
716605
public void afterPropertiesSet() throws Exception {
        scheduler = new ScheduledThreadPoolExecutor(DEFAULT_POOL, new NamedThreadFactory("Otter-Statistics-Client"),
                                                    new ThreadPoolExecutor.CallerRunsPolicy());
        scheduler.submit(new Runnable() {

            public void run() {
                doSendDelayCountEvent();
            }
        });
    }
416770
public void registerPropertyExclusions( Class target, String[] properties ) {
      if( target != null && properties != null && properties.length > 0 ) {
         Set set = (Set) exclusionMap.get( target );
         if( set == null ) {
            set = new HashSet();
            exclusionMap.put( target, set );
         }
         for( int i = 0; i < properties.length; i++ ) {
            if( !set.contains( properties[i] ) ) {
               set.add( properties[i] );
            }
         }
      }
   }
742202
public int getPropertyCount()
    {
        int count;
        if (_superClass == null)
            count = 0;
        else
            count = _superClass.getPropertyCount();

        for (AptPropertySet propertySet : _propertySets) {
            // if a property set is set to optional and hasSetters is set to false,
            // there isn't a getter or setter available for that property
            if (propertySet.hasSetters() || !propertySet.isOptional()) {
                count += propertySet.getProperties().size();
            }
        }

        count += _intfProps.size();
        return count;
    }
760209
private boolean isProperJoin(StorableProperty<?> property)
        throws SupportException, RepositoryException
    {
        if (!property.isJoin() || property.isQuery()) {
            return false;
        }

        // Make up a filter over the join's internal properties and then search
        // for an index that filters with no remainder.
        Filter<?> filter = Filter.getOpenFilter(property.getEnclosingType());
        int count = property.getJoinElementCount();
        for (int i=0; i<count; i++) {
            filter = filter.and(property.getInternalJoinElement(i).getName(), RelOp.EQ);
        }

        // Java generics are letting me down. I cannot use proper specification
        // because compiler gets confused with all the wildcards.
        Collection indexes = indexesFor(filter.getStorableType());

        if (indexes != null) {
            for (Object index : indexes) {
                FilteringScore score = FilteringScore.evaluate((StorableIndex) index, filter);
                if (score.getRemainderCount() == 0) {
                    return true;
                }
            }
        }

        return false;
    }
258579
private void countPropertyReference(PropertyIdValue property, int count) {
		PropertyRecord propertyRecord = getPropertyRecord(property);
		propertyRecord.referenceCount = propertyRecord.referenceCount + count;
	}
519737
protected void countTerms(UsageStatistics usageStatistics,
			TermedDocument termedDocument) {
		usageStatistics.countLabels += termedDocument.getLabels().size();
		for (MonolingualTextValue mtv : termedDocument.getLabels().values()) {
			countKey(usageStatistics.labelCounts, mtv.getLanguageCode(), 1);
		}

		usageStatistics.countDescriptions += termedDocument.getDescriptions()
				.size();
		for (MonolingualTextValue mtv : termedDocument.getDescriptions()
				.values()) {
			countKey(usageStatistics.descriptionCounts, mtv.getLanguageCode(),
					1);
		}

		for (String languageKey : termedDocument.getAliases().keySet()) {
			int count = termedDocument.getAliases().get(languageKey).size();
			usageStatistics.countAliases += count;
			countKey(usageStatistics.aliasCounts, languageKey, count);
		}
	}
237494
@Override
    protected void logIncrementalStatsByAccount(String account, RunStats stats) {
        DuplicationRunStats dstats = (DuplicationRunStats) stats;
        log.info("Session stats by account (incremental): account={} dups={} deletes={}",
                 account, dstats.getDups(), dstats.getDeletes());

    }
399175
public void addTaskProperties(Task task)
    {
    	if (task == null)
    		return;
        this.put(TrxMessageHeader.USER_ID, task.getProperty(DBParams.USER_ID));
//?         BaseDatabase.addDBProperties(m_mapMessageHeader, task, null);	// Note: m_mapMessageHeader is guaranteed not null by previous call.
    }
401690
@SuppressWarnings("unused")
    @Internal
    @UsedByGeneratedCode
    protected final void addProperty(@Nonnull BeanProperty<T, Object> property) {
        ArgumentUtils.requireNonNull("property", property);
        beanProperties.put(property.getName(), property);
    }
1238426
private void addPropertyCounters(UsageStatistics usageStatistics,
			PropertyIdValue property) {
		if (!usageStatistics.propertyCountsMain.containsKey(property)) {
			usageStatistics.propertyCountsMain.put(property, 0);
			usageStatistics.propertyCountsQualifier.put(property, 0);
			usageStatistics.propertyCountsReferences.put(property, 0);
		}
	}