Select Records Constituting Percentage of Total
This is very good question and a very hard one because your query is basically sensitive to the ordering. In other SQL database engines, this is easier to solve with use of window functions. Unfortunately, Access database engine does not support window functions.

A possible choice is to use subquery but this can get very expensive quickly because a subquery would have to be correlated and therefore re-calculated for all possible rows, making it O(too much n). For completeness' sake, here's a possible query:

SELECT 
  m.Item, 
  m.Quantity, 
  (
    SELECT SUM(x.Quantity) 
    FROM myTable AS x 
    WHERE x.Quantity &gt;= m.Quantity
  ) AS RunningSum, 
  (
    SELECT SUM(t.Quantity) 
    FROM myTable AS t
  ) * 0.8 AS PercentileThreshold
FROM myTable AS m
WHERE (
  SELECT SUM(x.Quantity) 
  FROM myTable AS x 
  WHERE x.Quantity &gt;= m.Quantity
) &lt;= (
  SELECT SUM(t.Quantity) 
  FROM myTable AS t
) * 0.8
ORDER BY m.Quantity DESC;


To avoid paying the expenses of multiple queries being executed several times over, you can combine some VBA with SQL. For instance, you can create the following VBA in a public standard module:

Private Type TPercentile
    PercentileThreshold As Currency
    PercentileValues As Scripting.Dictionary
End Type
Private This As TPercentile

Public Function StartPercentile(PercentileThreshold As Currency) As Boolean
    This.PercentileThreshold = Nz(DSum("Quantity", "myTable") * PercentileThreshold, 0)
    Set This.PercentileValues = New Scripting.Dictionary
    StartPercentile = True
End Function

Public Function Percentile(Key As String, Quantity As Variant) As Currency
    Dim PercentileValue As Currency

    If Not This.PercentileValues.Exists(Key) Then
        PercentileValue = Nz(DSum("Quantity", "myTable", "Quantity&gt;=" &amp; Nz(Quantity, 0)))
        This.PercentileValues.Add Key, PercentileValue
    End If
    Percentile = This.PercentileValues(Key)
End Function

Public Function PercentileThreshold() As Currency
    PercentileThreshold = This.PercentileThreshold
End Function


Your query then becomes:

SELECT 
  m.Item, 
  m.Quantity, 
  Percentile(m.Item,m.Quantity) AS Percentile, 
  PercentileThreshold() AS Threshold
FROM myTable AS m
WHERE StartPercentile(0.8) 
  AND Percentile([m].[Item],[m].[Quantity]) &lt;= PercentileThreshold()
ORDER BY m.Quantity DESC;


This enables you to handle a larger dataset by populating the dictionary only once and require less code to boot and you can easily generalize for other tables. The downside is that this is limited to only one active running query at a time. If this is unacceptable, then you need to add some kind of identifier that each query can then generate in their invocation to StartPercentile() function so that they have their own "instances". 

I also want to call your attention to one possible option for you - If you are reporting, Access already provides you with a Running Sum property on the Report so you could conceivably create a simple query, then apply a filter on a calculated control, rather than doing in the query. That yields much less code. 

You may wonder why I use Currency all over the place -- the answer is that I generally avoid using floating numbers such as Double which can cause unstable results due to rounding errors. Currency is a scaled integer and thus is not subject to such problems so it is a great data type to use for where you need fractions less than 4 decimal places. I should note that there is also a Decimal type but IME, it yields more problems than solutions and I never use it within Access/VBA context.