A FilterQuery ONLY stores document IDS. This makes it very fast to apply the filter to include/exclude documents. Good examples of this are when filtering products from search based on Country, Product Type, Availability, etc.

A normal query can perform the exact same function, but it has a very complex scoring system to determine &quot;relevance&quot;. I believe the documentation is indicating that scoring is only done on the Main Query, not on the Filter Query. This should also increase query speed.

So, I can query for:

    description:Kohler AND productType:Toilet

Or I can query for:

    description:Kohler
    with a FQ of productType:Toilet

The results would be the same, but the scores would be different. Also, if you get many different queries throughout the day that are for `productType:Toilet`, the FilterQuery would be cached making the overall query time faster.



fq is intended for a fixed list of values. If you search on q=sunroof+stereo and fq=Mustang solr will do text analysis on the q parameter since q=sunroof+stereo and q=stereo+sunroof will return the same result set. But when filtering the search via fq there is no analysis applied to the fq param and it&#39;s assumed all returned documents will match the fq so there is no need for it to modify the score of the docs that match.

I&#39;m trying to implement RC4 and DH key exchange in python. Problem is that I have no idea about how to convert the python long/int from the key exchange to the byte array I need for the RC4 implementation. Is there a simple way to convert a long to the required length byte array?

**Update**: forgot to mention that the numbers I&#39;m dealing with are 768 bit unsigned integers.

Convert python long/int to fixed size byte array

I have an unordered list, which can contain either an even or odd number of items. I&#39;m looking for a CSS-only way to remove the border from the last 2 ```li``` tags if the number of ```li```s is even. The `:last-child` pseudo-selector removes the last one regardless. 

    li {
    float: left;
    border-bottom: 1px solid #000;
    }
    
    li:last-child{
    border-bottom: none;
    }

###Works for Odd Numbers of ```li```s

    +============================================+
    +          1          |          2           +
    +--------------------------------------------+
    +          3          |                      +
    +============================================+



###But for even numbers, I need to remove the bottom of cell #3

    +============================================+
    +          1          |          2           +
    +--------------------------------------------+
    +          3          |          4           +
    +---------------------                       +
    +============================================+


So I figured I could use ```li:nth-last-child()``` but I can&#39;t figure out what should be the equation to grab the last odd child. 

It&#39;s not `2n+1`, `2n-1`, `n-1`, or anything I can think of. Please help. 



CSS Last Odd Child?

[SOLR docs](http://wiki.apache.org/solr/CommonQueryParameters#fq), state that **filter queries**, unlike the **main query**, do not influence the document score. Can anyone explain what does this mean exactly, preferably with an example.

Thanks.

SOLR filter-query vs main-query

<a href="http://wiki.apache.org/solr/CommonQueryParameters#fq" target="_blank" rel="noopener noreferrer">SOLR docs</a>, state that filter queries, unlike the main query, do not influence the document score. Can anyone explain what does this mean exactly, preferably with an example.
Thanks.

I&#39;m trying to write a custom filter method that takes an arbitrary number of *kwargs* and returns a list containing the elements of a database-like list that contain those *kwargs*.

For example, suppose `d1 = {&#39;a&#39;:&#39;2&#39;, &#39;b&#39;:&#39;3&#39;}` and `d2` = the same thing. `d1 == d2` results in True. But suppose `d2` = the same thing plus a bunch of other things. My method needs to be able to tell if **d1 in d2**, but Python can&#39;t do that with dictionaries.

Context:

I have a Word class, and each object has properties like `word`, `definition`, `part_of_speech`, and so on. I want to be able to call a filter method on the main list of these words, like `Word.objects.filter(word=&#39;jump&#39;, part_of_speech=&#39;verb-intransitive&#39;)`. I can&#39;t figure out how to manage these keys and values at the same time. But this could have larger functionality outside this context for other people.

How to check if one dictionary is a subset of another larger dictionary?

When I need to filter a data.frame, i.e., extract rows that meet certain conditions, I prefer to use the `subset` function:

    subset(airquality, Month == 8 &amp; Temp &gt; 90)

Rather than the `[` function:

    airquality[airquality$Month == 8 &amp; airquality$Temp &gt; 90, ]

There are two main reasons for my preference:

 1. I find the code reads better, from left to right. Even people who know nothing about R could tell what the `subset` statement above is doing.

 2. Because columns can be referred to as variables in the `select` expression, I can save a few keystrokes. In my example above, I only had to type `airquality` once with `subset`, but three times with `[`.

So I was living happy, using `subset` everywhere because it is shorter and reads better, even advocating its beauty to my fellow R coders. But yesterday my world broke apart. While reading the `subset` documentation, I notice this section:

&gt;Warning
&gt;
&gt;This is a convenience function intended for use interactively. For programming it is better to use the standard subsetting functions like [, and in particular the non-standard evaluation of argument subset can have unanticipated consequences.

Could someone help clarify what the authors mean?

First, what do they mean by &quot;*for use interactively*&quot;? I know what an interactive session is, as opposed to a script run in BATCH mode but I don&#39;t see what difference it should make.

Then, could you please explain &quot;*the non-standard evaluation of argument subset*&quot; and why it is dangerous, maybe provide an example?


Why is `[` better than `subset`?

I was wondering about the differences between Grep and Filter :

Filter : 

&gt; Reduce the set of matched elements to those that match the selector or
&gt; pass the function&#39;s test.

Grep : 

&gt; Finds the elements of an array which satisfy a filter
&gt; function. The original array is not affected.

 **ok.**

so if I do this in GREP :

    var arr = [ 1, 9, 3, 8, 6, 1, 5, 9, 4, 7, 3, 8, 6, 9, 1 ];
     
    myNewArray= jQuery.grep(arr, function(n, i){
      return (n != 5 &amp;&amp; i &gt; 4);
    });



I could do also : 

     var arr = [ 1, 9, 3, 8, 6, 1, 5, 9, 4, 7, 3, 8, 6, 9, 1 ];
        
    myNewArray= $(arr).filter( function(n, i){
      return (n != 5 &amp;&amp; i &gt; 4);
    });



In both situations I still can access to the original array...

so...where is the difference ?


Grep vs Filter in jQuery?

I would like to filter my data set on two conditions at once. 

Is it possible?  

I want something like this:

    mystuff = mystuff.filter(_.isX &amp;&amp; _.name == &quot;xyz&quot;)

Scala filter on two conditions

I have a utility script in Python:

    #!/usr/bin/env python
    import sys
    unique_lines = []
    duplicate_lines = []
    for line in sys.stdin:
      if line in unique_lines:
        duplicate_lines.append(line)
      else:
        unique_lines.append(line)
        sys.stdout.write(line)
    # optionally do something with duplicate_lines

This simple functionality (`uniq` without needing to sort first, stable ordering) must be available as a simple UNIX utility, mustn&#39;t it? Maybe a combination of filters in a pipe?

Reason for asking: needing this functionality on a system on which I cannot execute Python from anywhere.


Remove duplicate lines without sorting

I recently switched from Postgres to Solr and saw a ~50x speed up in our queries. The queries we run involve multiple ranges, and our data is vehicle listings. For example: &quot;Find all vehicles with mileage &lt; 50,000, $5,000 &lt; price &lt; $10,000, make=Mazda...&quot;

I created indices on all the relevant columns in Postgres, so it should be a pretty fair comparison. Looking at the query plan in Postgres though it was still just using a single index and then scanning (I assume because it couldn&#39;t make use of all the different indices).

As I understand it, Postgres and Solr use vaguely similar data structures (B-trees), and they both cache data in-memory. So I&#39;m wondering where such a large performance difference comes from.

What differences in architecture would explain this?

Why is Solr so much faster than Postgres?

What are the core architectural differences between these technologies?  

Also, what use cases are generally more appropriate for each?



Solr vs. ElasticSearch

I&#39;m preparing to deploy a Rails app on Heroku that requires full text search. Up to now I&#39;ve been running it on a VPS using MySQL with Sphinx.

However, if I want to use Sphinx or Solr on Heroku, I&#39;d need to pay for an add-on.

I notice that PostgreSQL (the DB used on Heroku) has built-in full text search capability.

Is there a reason I couldn&#39;t use Postgres&#39;s full-text search? Is it slower than Sphinx or is there some other major limitation?

Any reason not use PostgreSQL&#39;s built-in full text search on Heroku?

I know that Lucene and Solr are 2 differents [Apache projects][1] that are made to work together, but I don&#39;t understand what is the aim of each project.

For what I understood until now is that Lucene is used to create a search index and Solr use this index to perform searches.
Am I right or is this a totally different approach?


  [1]: http://lucene.apache.org/

Difference between solr and lucene


I struggle with understanding the difference between **collections and cores**. If I understand it correctly, cores are multiple indexes. Collection consists of cores, so essentially they share the same logic in separation, i.e. separate cores and collections have separate end-points.

I have the following scenario. I create a backend for cloud service for several online shops. Each shop has a set of products, to which customers can add reviews. I want to index static data (product information) separately from dynamic information(reviews) so I can improve performance.

How can I best separate in Solr???

Content Type	Original Author	Original Content on Stackoverflow
Question	mrd3650	View Question on Stackoverflow
Solution 1 - Filter	rfeak	View Answer on Stackoverflow
Solution 2 - Filter	d whelan	View Answer on Stackoverflow

SOLR filter-query vs main-query

Filter Problem Overview

Filter Solutions

Solution 1 - Filter

Solution 2 - Filter

CSS Last Odd Child?

Convert python long/int to fixed size byte array

Attributions