/*
public DeleteWithOptions delete(...) {
validate keys not null
return DeleteWithOptions(rte, clazz, meta, keys);
}
194874
private static MethodSpec buildDeleteByKeys(EntityMetaSignature signature) {
        ParameterizedTypeName returnType = genericType(DELETE_WITH_OPTIONS, signature.entityRawClass);
        final MethodSpec.Builder builder = MethodSpec.methodBuilder("deleteById")
                .addJavadoc("Delete an entity using its complete primary key")
                .addModifiers(Modifier.PUBLIC)
                .addStatement("$T keys = new $T<>()", LIST_OBJECT, ARRAY_LIST)
                .addStatement("$T encodedKeys = new $T<>()", LIST_OBJECT, ARRAY_LIST);

        signature.fieldMetaSignatures
                .stream()
                .filter(x -> x.context.columnType == PARTITION)
                .map(x -> Tuple3.of(x.context.fieldName, x.sourceType, (PartitionKeyInfo) x.context.columnInfo))
                .sorted(PARTITION_KEY_SORTER)
                .forEach(tuple ->
                        builder.addJavadoc("@param $L partition key '$L'", tuple._1(), tuple._1())
                                .addParameter(tuple._2(), tuple._1(), Modifier.FINAL)
                                .addStatement("$T.validateNotNull($L, $S, $S)", VALIDATOR, tuple._1(),
                                        "Partition key '%s' should not be null", tuple._1())
                                .addStatement("keys.add($L)", tuple._1())
                                .addStatement("encodedKeys.add($L.$L.encodeFromJava($N, cassandraOptions))",
                                        signature.className + META_SUFFIX, tuple._1(), tuple._1())
                );

        signature.fieldMetaSignatures
                .stream()
                .filter(x -> x.context.columnType == CLUSTERING)
                .map(x -> Tuple3.of(x.context.fieldName, x.sourceType, (ClusteringColumnInfo) x.context.columnInfo))
                .sorted(CLUSTERING_COLUMN_SORTER)
                .forEach(tuple ->
                        builder.addJavadoc("@param $L clustering column '$L'", tuple._1(), tuple._1())
                                .addParameter(tuple._2(), tuple._1(), Modifier.FINAL)
                                .addStatement("$T.validateNotNull($L, $S, $S)", VALIDATOR, tuple._1(),
                                        "Partition key '%s' should not be null", tuple._1())
                                .addStatement("keys.add($L)", tuple._1())
                                .addStatement("encodedKeys.add($L.$L.encodeFromJava($N, cassandraOptions))",
                                        signature.className + META_SUFFIX, tuple._1(), tuple._1()));

        builder.addJavadoc("@return DeleteWithOptions<$T>", signature.entityRawClass);

        builder.addStatement("final Object[] partitionKeysValues = keys.toArray()")
                .addStatement("final Object[] encodedPartitionKeyValues = encodedKeys.toArray()")
                .addStatement("return new $T(entityClass, meta, rte, partitionKeysValues, encodedPartitionKeyValues, $T.empty(), cassandraOptions)", returnType, OPTIONAL)
                .returns(returnType);


        return builder.build();
    }
293622
function () {
                var res = [];
                this._removeAllToArray(this._objectKeys, res);
                this._objectKeys = null;
                this._removeAllToArray(this._stringKeys, res);
                this._stringKeys = null;
                this._removeAllToArray(this._numberKeys, res);
                this._numberKeys = null;
                this._removeAllToArray(this._otherKeys, res);
                this._otherKeys = null;
                return res;
            }
1101298
function DeleteTreeControl(options) {
  if (!options) {
    options = {}
  }

  options.type = DeleteTreeControl.OID
  options.value = null

  Control.call(this, options)
  this.value = {}
}
919855
def delete(options = {})
      options = options.merge(bucket: @name)
      resp = @client.delete_bucket(options)
      resp.data
    end
234437
public ElementWithOptions removeOption(String value) {
        for (OptionGroup group : optionGroups.values()) {
            group.removeOption(value);
        }
        return this;
    }
931525
def delete(options = {})
      options = options.merge(queue_url: @url)
      resp = @client.delete_queue(options)
      resp.data
    end
1113609
@Override
	public boolean remove(Object o) {
		combine();
		return combined!=null && combined.remove(o);
	}
1208278
function remove(key, options) {
  let opts = { expires: -1 };

  if (options) {
    opts = { ...options, ...opts };
  }

  return set(key, 'a', opts);
}
98
function () {
        var option = clone(this.option);

        each(option, function (opts, mainType) {
            if (ComponentModel.hasClass(mainType)) {
                var opts = modelUtil.normalizeToArray(opts);
                for (var i = opts.length - 1; i >= 0; i--) {
                    // Remove options with inner id.
                    if (modelUtil.isIdInner(opts[i])) {
                        opts.splice(i, 1);
                    }
                }
                option[mainType] = opts;
            }
        });

        delete option[OPTION_INNER_KEY];

        return option;
    }
1144660
public int delete(Map<String, Object> fieldValues) {
		String whereClause = buildWhere(fieldValues.entrySet());
		String[] whereArgs = buildWhereArgs(fieldValues.values());
		return delete(whereClause, whereArgs);
	}
204707
public boolean delete(String key) {
        Jedis jedis = null;
        try {
            jedis = this.jedisPool.getResource();
            jedis.del(SafeEncoder.encode(key));
            logger.info("delete key:" + key);

            return true;
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            this.jedisPool.returnBrokenResource(jedis);
        } finally {
            if (jedis != null) {
                this.jedisPool.returnResource(jedis);
            }
        }
        return false;
    }
1353638
public DeleteOptions copy() {
        DeleteOptions deleteOptions = new DeleteOptions()
            .writeConcern(getWriteConcern());

        if (getCollation() != null) {
            deleteOptions.collation(Collation.builder(getCollation()).build());
        }

        return deleteOptions;
    }
1338164
def delete(options = {})
      return each({ match: '*', count: 500, max_iterations: 1_000_000, batch_size: 500 }.merge(options)) do |keys|
        @connection.del(*keys)
      end
    end
584797
function delete() {
        $sizes   = array_keys($this->getSizes());
        $sizes[] = null;
        $sizes[] = '_';
        foreach($sizes as $size) {
            $f = $this->makePath($size);
            if($f) {
                \File::delete($f);
            }
        }
    }
742957
public alluxio.grpc.DeletePOptionsOrBuilder getOptionsOrBuilder() {
    return options_ == null ? alluxio.grpc.DeletePOptions.getDefaultInstance() : options_;
  }
1372122
public function delete()
    {
        self::$instance->reset();
        $this->sql('DELETE');
        $this->oosql_where = null;
        $numargs = func_num_args();

        if ($numargs > 0) {
            if ($numargs > 1) {
                $this->oosql_del_multiFlag = true;
                $this->oosql_del_numargs = $numargs;
            }
            $arg_list = func_get_args();
            if (is_array($arg_list[0])) {
                $this->sql(' FROM ' . $this->oosql_table);
                $this->where($arg_list[0][0] . ' = ?', $arg_list[0][1]);
                return $this;
            }
            $this->oosql_sql .= ' FROM';
            for ($i = 0; $i < $numargs; $i++) {
                if ($i != 0 && $numargs > 1) {
                    $this->sql(',');
                }
                $this->sql(' ' . $arg_list[$i]);
            }

        } else {
            $this->oosql_fromFlag = true;
        }


        return $this;
    }
863370
@Override
	public void removeByCPDefinitionOptionRelId(long CPDefinitionOptionRelId) {
		for (CPDefinitionOptionValueRel cpDefinitionOptionValueRel : findByCPDefinitionOptionRelId(
				CPDefinitionOptionRelId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
				null)) {
			remove(cpDefinitionOptionValueRel);
		}
	}