Performs filtering for special cases (i.e. table format factories with schema derivation).
351600
private static List<String> filterSupportedPropertiesFactorySpecific(
		TableFactory factory,
		List<String> keys) {

		if (factory instanceof TableFormatFactory) {
			boolean includeSchema = ((TableFormatFactory) factory).supportsSchemaDerivation();
			return keys.stream().filter(k -> {
				if (includeSchema) {
					return k.startsWith(Schema.SCHEMA + ".") ||
						k.startsWith(FormatDescriptorValidator.FORMAT + ".");
				} else {
					return k.startsWith(FormatDescriptorValidator.FORMAT + ".");
				}
			}).collect(Collectors.toList());
		} else {
			return keys;
		}
	}
461661
function buildFilters(filters) {
    var builtFilters = [];
    filters.forEach(function(filter) {
      builtFilters.push(MongoDatabase.buildFilter(filter));
    });
    return builtFilters;
  }
563951
public static function applyQueryFilters($query, $filters, $columns, $table)
	{
		// Wrap in a complex where so we don't break soft delete checks
		$query->where(
			function ($query) use ($filters, $columns, $table) {
				self::filterQuery($query, $filters, $columns, $table);
			});
	}
1041201
def _process_schema(self, schema_dict, validators):
        
        schema_flat = util.flatten(schema_dict)

        for key, expression in schema_flat.items():
            try:
                schema_flat[key] = syntax.parse(expression, validators)
            except SyntaxError as e:
                # Tack on some more context and rethrow.
                error = str(e) + ' at node \'%s\'' % key
                raise SyntaxError(error)
        return schema_flat
276004
private static <T> List<TableFactory> filterByContext(
		Class<T> factoryClass,
		Map<String, String> properties,
		List<TableFactory> foundFactories,
		List<TableFactory> classFactories) {

		List<TableFactory> matchingFactories = classFactories.stream().filter(factory -> {
			Map<String, String> requestedContext = normalizeContext(factory);

			Map<String, String> plainContext = new HashMap<>(requestedContext);
			// we remove the version for now until we have the first backwards compatibility case
			// with the version we can provide mappings in case the format changes
			plainContext.remove(CONNECTOR_PROPERTY_VERSION);
			plainContext.remove(FORMAT_PROPERTY_VERSION);
			plainContext.remove(METADATA_PROPERTY_VERSION);
			plainContext.remove(STATISTICS_PROPERTY_VERSION);
			plainContext.remove(CATALOG_PROPERTY_VERSION);

			// check if required context is met
			return plainContext.keySet().stream().allMatch(e -> properties.containsKey(e) && properties.get(e).equals(plainContext.get(e)));
		}).collect(Collectors.toList());

		if (matchingFactories.isEmpty()) {
			throw new NoMatchingTableFactoryException(
				"No context matches.",
				factoryClass,
				foundFactories,
				properties);
		}

		return matchingFactories;
	}
1216821
public final Map<String, Object> applyFilters(
            final Map<String, Object> row) {
        Map<String, Object> filteringRow = new LinkedHashMap<>(row);
        assertFilterListExists();
        for (IDataFilter filter : getFilters()) {
            filteringRow = filter.apply(filteringRow);
        }

        return filteringRow;
    }
690032
private Multimap<Type, Class<?>> filterProducibleClasses(Map<Key<?>, Class<?>> bindings) {
        Multimap<Type, Class<?>> defaultFactoryToBind = ArrayListMultimap.create();
        bindings.entrySet()
                .stream()
                .filter(entry -> isCandidate(entry.getKey()
                        .getTypeLiteral()
                        .getType()))
                .forEach(entry -> defaultFactoryToBind.put(entry.getKey()
                        .getTypeLiteral()
                        .getType(), entry.getValue()));
        return defaultFactoryToBind;
    }
1051344
def partial_schema(schema, filtered_fields):
    
    return Schema({
        k: v for k, v in schema.schema.items()
        if getattr(k, 'schema', k) not in filtered_fields
    }, extra=ALLOW_EXTRA)
279969
def _verify_filters(self, kwargs, obj, encode=False):
        """"""
        return (filters.legacy_filter_formatter if encode else filters.filter_formatter)(
            kwargs,
            obj._get_attributes_map()
        )
591308
protected function generateFilters()
    {

        $filters = $this->request->query->get('filters');

        $filters = json_decode($filters, true);
        $rules = $filters['rules'];
        $groupOp = $filters['groupOp']; //AND or OR

        if ($rules) {
            foreach ($rules as $rule) {
                foreach ($this->columns as $column) {
                    if ($column->getFieldIndex() == $rule['field']) {
                        $filterMapper = FilterMapperFactory::getFilterMapper($this, $column);
                        $filterMapper->execute($rule, $groupOp);
                    }
                }
            }
        }
    }
856978
public void validate(Schema schema) {
        if (queryCondition != null || filterCondition != null) {
            query(schema, null);
        }
        if (sort != null) {
            sort.sort(schema);
        }
    }
372123
public void prepare() {
        for(JavaClass jc: heap.getAllClasses()) {
            for(TypeFilterStep it: interestingTypes) {
                if (it.evaluate(jc)) {
                    rootClasses.add(jc.getName());
                }
            }
            for(TypeFilterStep bt: blacklistedTypes) {
                if (bt.evaluate(jc)) {
                    blacklist.add(jc.getName());
                }
            }
            for(PathStep[] bp: blacklistedMethods) {
                TypeFilterStep ts = (TypeFilterStep) bp[0];
                String fn = ((FieldStep) bp[1]).getFieldName();
                if (ts.evaluate(jc)) {
                    for(Field f: jc.getFields()) {
                        if (fn == null || fn.equals(f.getName())) {
                            blacklist.add(jc.getName() + "#" + f.getName());
                        }
                    }
                }
            }
        }
    }
1196942
private void reduceNameFilter(QueryFilter filter, ColumnFamily container, long sstableTimestamp)
    {
        if (container == null)
            return;

        for (Iterator<CellName> iterator = ((NamesQueryFilter) filter.filter).columns.iterator(); iterator.hasNext(); )
        {
            CellName filterColumn = iterator.next();
            Cell cell = container.getColumn(filterColumn);
            if (cell != null && cell.timestamp() > sstableTimestamp)
                iterator.remove();
        }
    }
1242455
public Filter convert(Criterion criterionDto, List<AttributeDescriptor> schema) {
		FilterContext fc = new FilterContext();
		fc.setSchema(schema);
		criterionDto.accept(this, fc);
		try {
			log.debug("Filter converted : " + ECQL.toCQL(fc.getFilter()));
		} catch (Exception e) {
			// ignore
		}
		return fc.getFilter();
	}
1169241
function  matchSQLFilter(tableSchema, whereCol)  {
	for (var i in whereCol)  {
		var  col = whereCol[i],
			 schema = tableSchema[col.tbName];

		if (!schema)
			throw  new Error('A filter column refers to an unknown table [' + col.tbName + ']');

		if (schema.columns.indexOf(col.col) < 0)
			return  false;
	}
	return  true;
}
383890
def _validate_filters_ndb(cls, filters, model_class):
    """"""
    if not filters:
      return

    properties = model_class._properties

    for f in filters:
      prop, _, val = f
      if prop not in properties:
        raise errors.BadReaderParamsError(
            "Property %s is not defined for entity type %s",
            prop, model_class._get_kind())

      # Validate the value of each filter. We need to know filters have
      # valid value to carry out splits.
      try:
        properties[prop]._do_validate(val)
      except db.BadValueError, e:
        raise errors.BadReaderParamsError(e)
64015
def filter(self, table, groups, filter_string):
        """"""
        query = filter_string.lower()
        return [group for group in groups
                if query in group.name.lower()]