92

如何使用 SQLAlchemy 从表中选择一个或多个随机行？

4

10 回答 10

138

这在很大程度上是一个特定于数据库的问题。

我知道 PostgreSQL、SQLite、MySQL 和 Oracle 可以通过随机函数进行排序，因此您可以在 SQLAlchemy 中使用它：

from  sqlalchemy.sql.expression import func, select

select.order_by(func.random()) # for PostgreSQL, SQLite

select.order_by(func.rand()) # for MySQL

select.order_by('dbms_random.value') # For Oracle

接下来，您需要通过您需要的记录数来限制查询（例如使用.limit()）。

请记住，至少在 PostgreSQL 中，选择随机记录具有严重的性能问题；这是关于它的好文章。

于 2008-09-13T20:09:28.533 回答
26

如果您正在使用 orm 并且表不大（或者您缓存了它的行数）并且您希望它独立于数据库，那么真正简单的方法是。

import random
rand = random.randrange(0, session.query(Table).count()) 
row = session.query(Table)[rand]

这有点作弊，但这就是您使用 orm 的原因。

于 2008-12-24T03:22:30.533 回答
23

有一种简单的方法可以拉取独立于数据库的随机行。只需使用 .offset() 。无需拉所有行：

import random
query = DBSession.query(Table)
rowCount = int(query.count())
randomRow = query.offset(int(rowCount*random.random())).first()

Table 在哪里是你的表（或者你可以在那里放置任何查询）。如果您想要几行，那么您可以多次运行，并确保每一行与前一行不同。

于 2013-02-16T02:19:56.087 回答
23

这里有四种不同的变体，从最慢到最快排序。timeit底部的结果：

from sqlalchemy.sql import func
from sqlalchemy.orm import load_only

def simple_random():
    return random.choice(model_name.query.all())

def load_only_random():
    return random.choice(model_name.query.options(load_only('id')).all())

def order_by_random():
    return model_name.query.order_by(func.random()).first()

def optimized_random():
    return model_name.query.options(load_only('id')).offset(
            func.floor(
                func.random() *
                db.session.query(func.count(model_name.id))
            )
        ).limit(1).all()

timeit在我的 Macbook 上针对 300 行的 PostgreSQL 表运行 10,000 次的结果：

simple_random(): 
    90.09954111799925
load_only_random():
    65.94714171699889
order_by_random():
    23.17819356000109
optimized_random():
    19.87806927999918

您可以很容易地看到 usingfunc.random()比将所有结果返回到 Python 的random.choice().

此外，随着表大小的增加，性能order_by_random()会显着下降，因为ORDER BY需要全表扫描，而COUNTinoptimized_random()可以使用索引。

于 2015-11-07T12:55:09.983 回答
7

一些 SQL DBMS，即 Microsoft SQL Server、DB2 和PostgreSQL ，已经实现了 SQL:2003TABLESAMPLE子句。在 1.1 版中添加了对 SQLAlchemy 的支持。它允许使用不同的采样方法返回表格样本——标准要求SYSTEM和BERNOULLI，它返回表格的所需近似百分比。

在 SQLAlchemy中FromClause.tablesample()，tablesample()用于生成TableSample构造：

# Approx. 1%, using SYSTEM method
sample1 = mytable.tablesample(1)

# Approx. 1%, using BERNOULLI method
sample2 = mytable.tablesample(func.bernoulli(1))

与映射类一起使用时有一个小问题：生成的TableSample对象必须具有别名才能用于查询模型对象：

sample = aliased(MyModel, tablesample(MyModel, 1))
res = session.query(sample).all()

由于许多答案都包含性能基准，因此我还将在此处包含一些简单的测试。在 PostgreSQL 中使用一个包含大约一百万行和一个整数列的简单表，选择（大约）1% 的样本：

In [24]: %%timeit
    ...: foo.select().\
    ...:     order_by(func.random()).\
    ...:     limit(select([func.round(func.count() * 0.01)]).
    ...:           select_from(foo).
    ...:           as_scalar()).\
    ...:     execute().\
    ...:     fetchall()
    ...: 
307 ms ± 5.72 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

In [25]: %timeit foo.tablesample(1).select().execute().fetchall()
6.36 ms ± 188 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

In [26]: %timeit foo.tablesample(func.bernoulli(1)).select().execute().fetchall()
19.8 ms ± 381 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

在急于使用SYSTEM抽样方法之前，应该知道它对页面进行抽样，而不是对单个元组进行抽样，因此它可能不适用于小表，并且如果表是聚集的，则可能不会产生随机结果。

如果使用不允许将样本百分比/行数和种子作为参数传递的方言，以及不内联值的驱动程序，则如果它们是静态的，则将值作为文字 SQL 文本传递，或者使用自定义内联它们SQLA 编译器扩展：

from sqlalchemy.ext.compiler import compiles
from sqlalchemy.sql import TableSample

@compiles(TableSample)
def visit_tablesample(tablesample, self, asfrom=False, **kw):
    """ Compile `TableSample` with values inlined.
    """
    kw_literal_binds = {**kw, "literal_binds": True}
    text = "%s TABLESAMPLE %s" % (
        self.visit_alias(tablesample, asfrom=True, **kw),
        tablesample._get_method()._compiler_dispatch(self, **kw_literal_binds),
    )

    if tablesample.seed is not None:
        text += " REPEATABLE (%s)" % (
            tablesample.seed._compiler_dispatch(self, **kw_literal_binds)
        )

    return text

from sqlalchemy import table, literal, text

# Static percentage
print(table("tbl").tablesample(text("5 PERCENT")))
# Compiler inlined values
print(table("tbl").tablesample(5, seed=literal(42)))
于 2018-10-07T20:00:36.487 回答
1

这是我选择表的随机行的函数： 

from sqlalchemy.sql.expression import func

def random_find_rows(sample_num):
    if not sample_num:
        return []

    session = DBSession()
    return session.query(Table).order_by(func.random()).limit(sample_num).all()
于 2018-05-15T08:03:38.180 回答
0

这是我使用的解决方案：

from random import randint

rows_query = session.query(Table)                # get all rows
if rows_query.count() > 0:                       # make sure there's at least 1 row
    rand_index = randint(0,rows_query.count()-1) # get random index to rows 
    rand_row   = rows_query.all()[rand_index]    # use random index to get random row
于 2017-03-14T07:32:37.297 回答
-3

此解决方案将选择单个随机行

此解决方案要求主键名为 id，如果尚未命名，则应为： 

import random
max_model_id = YourModel.query.order_by(YourModel.id.desc())[0].id
random_id = random.randrange(0,max_model_id)
random_row = YourModel.query.get(random_id)
print random_row
于 2014-01-20T19:18:12.990 回答
-3

使用这个最简单的方法这个例子从数据库中选择一个随机问题： -

#first import the random module
import random

#then choose what ever Model you want inside random.choise() method
get_questions = random.choice(Question.query.all())
于 2020-06-11T09:58:34.617 回答
-8

通过 SQL 有几种方法，具体取决于所使用的数据库。

（我认为 SQLAlchemy 无论如何都可以使用所有这些）

mysql:

SELECT colum FROM table
ORDER BY RAND()
LIMIT 1

PostgreSQL：

SELECT column FROM table
ORDER BY RANDOM()
LIMIT 1

微软SQL：

SELECT TOP 1 column FROM table
ORDER BY NEWID()

IBM DB2：

SELECT column, RAND() as IDX
FROM table
ORDER BY IDX FETCH FIRST 1 ROWS ONLY

甲骨文：

SELECT column FROM
(SELECT column FROM table
ORDER BY dbms_random.value)
WHERE rownum = 1

但是我不知道任何标准方式

于 2008-09-13T20:04:11.103 回答