Shortcut for {@link #dropAggregate(CqlIdentifier, CqlIdentifier)
dropAggregate(CqlIdentifier.fromCql(keyspace),CqlIdentifier.fromCql(aggregateName)}.
423564
@NonNull
  public static Drop dropAggregate(@Nullable String keyspace, @NonNull String aggregateName) {
    return new DefaultDrop(
        keyspace == null ? null : CqlIdentifier.fromCql(keyspace),
        CqlIdentifier.fromCql(aggregateName),
        "AGGREGATE");
  }
1273426
@NonNull
  public static SelectFrom selectFrom(@Nullable String keyspace, @NonNull String table) {
    return selectFrom(
        keyspace == null ? null : CqlIdentifier.fromCql(keyspace), CqlIdentifier.fromCql(table));
  }
1324231
function (aggId, cmd, clb) {
    if (!aggId || !_.isString(aggId)) {
      var err = new Error('Please pass a valid aggregate id!');
      debug(err);
      throw err;
    }
    if (!cmd || !_.isObject(cmd)) {
      var err = new Error('Please pass a valid command!');
      debug(err);
      throw err;
    }
    if (!clb || !_.isFunction(clb)) {
      var err = new Error('Please pass a valid callback!');
      debug(err);
      throw err;
    }

    this.queue[aggId] = this.queue[aggId] || [];
    this.queue[aggId].push({ command: cmd, callback: clb })
  }
513073
function (aggId) {
    if (!aggId || !_.isString(aggId)) {
      var err = new Error('Please pass a valid aggregate id!');
      debug(err);
      throw err;
    }

    if (this.queue[aggId] && this.queue[aggId].length > 0) {
      var nextCmd = this.queue[aggId][0];
      return nextCmd;
    }

    return null;
  }
759747
@NonNull
  public static Drop dropType(@Nullable CqlIdentifier keyspace, @NonNull CqlIdentifier typeName) {
    return new DefaultDrop(keyspace, typeName, "TYPE");
  }
411481
@NonNull
  public static CreateAggregateStart createAggregate(
      @Nullable CqlIdentifier keyspace, @NonNull CqlIdentifier aggregateName) {
    return new DefaultCreateAggregate(keyspace, aggregateName);
  }
705171
private static int aggregateDimValue(
      final int[] positions,
      final BufferAggregator[] theAggregators,
      final ByteBuffer resultsBuf,
      final int numBytesPerRecord,
      final int[] aggregatorOffsets,
      final int aggSize,
      final int aggExtra,
      final int dimIndex,
      int currentPosition
  )
  {
    if (SKIP_POSITION_VALUE == positions[dimIndex]) {
      return currentPosition;
    }
    if (INIT_POSITION_VALUE == positions[dimIndex]) {
      positions[dimIndex] = currentPosition * numBytesPerRecord;
      currentPosition++;
      final int pos = positions[dimIndex];
      for (int j = 0; j < aggSize; ++j) {
        theAggregators[j].init(resultsBuf, pos + aggregatorOffsets[j]);
      }
    }
    final int position = positions[dimIndex];

    switch (aggExtra) {
      case 7:
        theAggregators[6].aggregate(resultsBuf, position + aggregatorOffsets[6]);
        // fall through
      case 6:
        theAggregators[5].aggregate(resultsBuf, position + aggregatorOffsets[5]);
        // fall through
      case 5:
        theAggregators[4].aggregate(resultsBuf, position + aggregatorOffsets[4]);
        // fall through
      case 4:
        theAggregators[3].aggregate(resultsBuf, position + aggregatorOffsets[3]);
        // fall through
      case 3:
        theAggregators[2].aggregate(resultsBuf, position + aggregatorOffsets[2]);
        // fall through
      case 2:
        theAggregators[1].aggregate(resultsBuf, position + aggregatorOffsets[1]);
        // fall through
      case 1:
        theAggregators[0].aggregate(resultsBuf, position + aggregatorOffsets[0]);
    }
    for (int j = aggExtra; j < aggSize; j += AGG_UNROLL_COUNT) {
      theAggregators[j].aggregate(resultsBuf, position + aggregatorOffsets[j]);
      theAggregators[j + 1].aggregate(resultsBuf, position + aggregatorOffsets[j + 1]);
      theAggregators[j + 2].aggregate(resultsBuf, position + aggregatorOffsets[j + 2]);
      theAggregators[j + 3].aggregate(resultsBuf, position + aggregatorOffsets[j + 3]);
      theAggregators[j + 4].aggregate(resultsBuf, position + aggregatorOffsets[j + 4]);
      theAggregators[j + 5].aggregate(resultsBuf, position + aggregatorOffsets[j + 5]);
      theAggregators[j + 6].aggregate(resultsBuf, position + aggregatorOffsets[j + 6]);
      theAggregators[j + 7].aggregate(resultsBuf, position + aggregatorOffsets[j + 7]);
    }
    return currentPosition;
  }
946783
@Transactional("aggrEventsTransactionManager")
    @Override
    public ExternalEventAggregationConfiguration deleteData(String id) {
        final ExternalEventAggregationConfiguration data = this.exportData(id);

        for (final AggregatedIntervalConfig aggregatedIntervalConfig :
                this.aggregationManagementDao.getAggregatedIntervalConfigs()) {
            this.aggregationManagementDao.deleteAggregatedIntervalConfig(aggregatedIntervalConfig);
        }

        for (final AggregatedGroupConfig aggregatedGroupConfig :
                this.aggregationManagementDao.getAggregatedGroupConfigs()) {
            this.aggregationManagementDao.deleteAggregatedGroupConfig(aggregatedGroupConfig);
        }

        this.aggregationManagementDao.setAcademicTermDetails(
                Collections.<AcademicTermDetail>emptyList());

        this.aggregationManagementDao.setQuarterDetails(
                EventDateTimeUtils.createStandardQuarters());

        return data;
    }
155274
public static function createAggregateQueryHandlerWith(string $inputChannelName, string $aggregateClassName, string $methodName): self
    {
        return new self($inputChannelName, $aggregateClassName, $methodName, false, "", true);
    }
491084
@NonNull
  public static Drop dropFunction(@NonNull String functionName) {
    return new DefaultDrop(CqlIdentifier.fromCql(functionName), "FUNCTION");
  }
414718
function (aggregate, streams, clb) {
        if (hadNoAggregateId) return clb(null, aggregate, streams);
        debug('');
        self.checkAggregateLock(concatenatedId, function (err) {
          clb(err, aggregate, streams);
        });
      }
763163
public void dropTrigger(String tableName, String geometryColumnName,
			String triggerName) {

		String sqlName = GeoPackageProperties.getProperty(TRIGGER_PROPERTY,
				TRIGGER_DROP_PROPERTY);
		executeSQL(sqlName, tableName, geometryColumnName, null, triggerName);
	}
693604
def _register_aggregate(agg, con):
    
    nargs = number_of_arguments(agg.step) - 1  # because self
    con.connection.connection.create_aggregate(agg.__name__, nargs, agg)
871128
def aggregate(self, *args, **kwargs):
        
        if self.query.distinct_fields:
            raise NotImplementedError("aggregate() + distinct(fields) not implemented.")
        for arg in args:
            # The default_alias property may raise a TypeError, so we use
            # a try/except construct rather than hasattr in order to remain
            # consistent between PY2 and PY3 (hasattr would swallow
            # the TypeError on PY2).
            try:
                arg.default_alias
            except (AttributeError, TypeError):
                raise TypeError("Complex aggregates require an alias")
            kwargs[arg.default_alias] = arg

        if django.VERSION < (2, 0):
            query = self.query.clone(CTEAggregateQuery)
        else:
            query = self.query.chain(CTEAggregateQuery)
        for (alias, aggregate_expr) in kwargs.items():
            query.add_annotation(aggregate_expr, alias, is_summary=True)
            if not query.annotations[alias].contains_aggregate:
                raise TypeError("%s is not an aggregate expression" % alias)
        return query.get_aggregation(self.db, kwargs.keys())
303706
@NonNull
  public static Drop dropMaterializedView(@Nullable String keyspace, @NonNull String viewName) {
    return dropMaterializedView(
        keyspace == null ? null : CqlIdentifier.fromCql(keyspace), CqlIdentifier.fromCql(viewName));
  }
1372643
private MetricAggregate getAggregate(final MetricIdentity identity) {

		// get the map from utc minute to aggregate for this metric

		if (!aggregates.containsKey(identity)) {
			aggregates.put(identity, new HashMap<Long, MetricAggregate>());			
		}
		
		Map<Long, MetricAggregate> metricAggregates = aggregates.get(identity);
		
		// get the aggregate for this minute
		
		if (!metricAggregates.containsKey(currentMinute)) {
		
			MetricAggregate initialAggregate = MetricAggregate.fromMetricIdentity(identity, currentMinute);
			
			if (identity.getType().equals(MetricMonitorType.GAUGE)) {
				if (lastValues.containsKey(identity)) {
					initialAggregate.setValue(lastValues.get(identity));
				}
			}
						
			metricAggregates.put(currentMinute, initialAggregate);
		}

		MetricAggregate aggregate = metricAggregates.get(currentMinute);
		
		return aggregate;
	}
1160875
@NonNull
  public static Drop dropFunction(@Nullable String keyspace, @NonNull String functionName) {
    return new DefaultDrop(
        keyspace == null ? null : CqlIdentifier.fromCql(keyspace),
        CqlIdentifier.fromCql(functionName),
        "FUNCTION");
  }