Справочник по командам Python ReQL
Ищете документацию по драйверу сообщества?
Найдите страницу проекта для вашего драйвера для получения конкретной документации по ReQL.
Доступ к ReQL
r
r → r
Пространство имен ReQL верхнего уровня.
Пример: Настройка пространства имен верхнего уровня.
from rethinkdb import RethinkDB
r = RethinkDB()
connect
r.connect(options) → connection
Создать новое подключение к серверу базы данных. Параметры ключевых слов:
-
host: хост экземпляра RethinkDB. Значение по умолчанию —localhost. -
port: порт драйвера, по умолчанию28015. -
db: база данных, используемая, если явно не указана в запросе, по умолчаниюtest. -
user: учетная запись пользователя для подключения (по умолчаниюadmin). -
password: пароль для учетной записи пользователя для подключения (по умолчанию'', пустое). -
timeout: время ожидания в секундах для открытия подключения (по умолчанию20). -
ssl: хеш опций для поддержки SSL-соединений (по умолчаниюNone). В настоящее время доступна только одна опция, и если указана опцияssl, этот ключ необходим:-
ca_certs: путь к сертификату SSL CA.
-
Если подключение не может быть установлено, будет выброшено исключение ReqlDriverError.
Пример: Открыть подключение, используя хост и порт по умолчанию, указав базу данных по умолчанию.
conn = r.connect(db='marvel')
repl
conn.repl()
Установить подключение по умолчанию для упрощения использования REPL. Позволяет вызывать .run() для запросов без указания подключения.
Пример: Установить подключение по умолчанию для REPL, а затем вызвать run() без указания подключения.
r.connect(db='marvel').repl()
r.table('heroes').run()
close
conn.close(noreply_wait=True)
Закрыть открытое подключение.
Пример: Закрыть открытое подключение, ожидая завершения запросов noreply.
conn.close()
reconnect
conn.reconnect(noreply_wait=True)
Закрыть и открыть заново подключение.
Пример: Отменить незавершенные запросы/запросы, которые больше не нужны.
conn.reconnect(noreply_wait=False)
use
conn.use(db_name)
Изменить базу данных по умолчанию для этого подключения.
Пример: Изменить базу данных по умолчанию, чтобы нам не нужно было указывать базу данных при ссылке на таблицу.
conn.use('marvel')
r.table('heroes').run(conn) # refers to r.db('marvel').table('heroes')
run
query.run(conn[, options]) → cursor query.run(conn[, options]) → object
Выполнить запрос на подключении, вернув либо единственный результат JSON, либо курсор, в зависимости от запроса.
Пример: Выполнить запрос на подключении conn и вывести каждую строку в результате.
for doc in r.table('marvel').run(conn):
print doc
changes
stream.changes([options]) → stream singleSelection.changes([options]) → stream
Преобразовать запрос в changefeed, бесконечный поток объектов, представляющих изменения в результатах запроса по мере их возникновения. Changefeed может возвращать изменения в таблице или в отдельном документе (changefeed «точки»). Команды, такие как filter или map, могут использоваться перед командой changes для преобразования или фильтрации вывода, и многие команды, работающие с последовательностями, могут быть объединены после changes.
Пример: Подписаться на изменения в таблице.
Начать мониторинг changefeed в одном клиенте:
for change in r.table('games').changes().run(conn):
print change
По мере выполнения этих запросов во втором клиенте, первый клиент будет получать и выводить следующие объекты:
> r.table('games').insert({'id': 1}).run(conn)
{'old_val': None, 'new_val': {'id': 1}}
> r.table('games').get(1).update({'player1': 'Bob'}).run(conn)
{'old_val': {'id': 1}, 'new_val': {'id': 1, 'player1': 'Bob'}}
> r.table('games').get(1).replace({'id': 1, 'player1': 'Bob', 'player2': 'Alice'}).run(conn)
{'old_val': {'id': 1, 'player1': 'Bob'},
'new_val': {'id': 1, 'player1': 'Bob', 'player2': 'Alice'}}
> r.table('games').get(1).delete().run(conn)
{'old_val': {'id': 1, 'player1': 'Bob', 'player2': 'Alice'}, 'new_val': None}
> r.table_drop('games').run(conn)
ReqlRuntimeError: Changefeed aborted (table unavailable)
noreply_wait
conn.noreply_wait()
noreply_wait гарантирует, что предыдущие запросы с флагом noreply были обработаны сервером. Обратите внимание, что эта гарантия применима только к запросам, выполненным на данном подключении.
Пример: Мы ранее выполняли запросы с аргументом noreply установленным в True. Теперь подождите, пока сервер обработает их.
conn.noreply_wait()
server
conn.server()
Возвращает информацию о сервере, используемом подключением.
Пример: Возвращение информации о сервере.
> conn.server()
{
"id": "404bef53-4b2c-433f-9184-bc3f7bda4a15",
"name": "amadeus",
"proxy": False
}
set_loop_type
r.set_loop_type(string)
Установить модель асинхронной событийной петли. Поддерживаются две модели:
Пример: Чтение данных таблицы с использованием Tornado.
r.set_loop_type("tornado")
conn = r.connect(host='localhost', port=28015)
@gen.coroutine
def use_cursor(conn):
# Print every row in the table.
cursor = yield r.table('test').order_by(index="id").run(yield conn)
while (yield cursor.fetch_next()):
item = yield cursor.next()
print(item)
Более подробная информация с примерами Tornado и Twisted доступна в статье документации по асинхронным подключениям.
Курсоры
next
cursor.next([wait=True])
Получить следующий элемент в курсоре.
Пример: Получить следующий элемент.
cursor = r.table('superheroes').run(conn)
doc = cursor.next()
for
for items in cursor: for items in array: for items in feed:
Ленивая итерация по набору результатов по одному элементу за раз.
Пример: Обработаем все элементы!
cursor = r.table('users').run(conn)
for doc in cursor:
process_row(doc)
list
list(cursor)
Получить все результаты в виде списка.
Пример: Для небольших наборов результатов может быть удобнее обрабатывать их сразу в виде массива.
cursor = r.table('users').run()
users = list(cursor)
process_results(users)
close
cursor.close()
Закрыть курсор. Закрытие курсора отменяет соответствующий запрос и освобождает память, связанную с открытым запросом.
Пример: Закрыть курсор.
cursor.close()
Управление базами данных
db_create
r.db_create(db_name) → object
Создать базу данных. База данных RethinkDB — это набор таблиц, аналогично реляционным базам данных.
Пример: Создать базу данных с именем «superheroes».
r.db_create('superheroes').run(conn)
{
"config_changes": [
{
"new_val": {
"id": "e4689cfc-e903-4532-a0e6-2d6797a43f07",
"name": "superheroes"
},
"old_val": None
}
],
"dbs_created": 1
}
db_drop
r.db_drop(db_name) → object
Удалить базу данных. База данных, все её таблицы и соответствующие данные будут удалены.
Пример: Удалить базу данных с именем «superheroes».
r.db_drop('superheroes').run(conn)
{
"config_changes": [
{
"old_val": {
"id": "e4689cfc-e903-4532-a0e6-2d6797a43f07",
"name": "superheroes"
},
"new_val": None
}
],
"tables_dropped": 3,
"dbs_dropped": 1
}
db_list
r.db_list() → array
Список всех имен баз данных в системе. Результат — список строк.
Пример: Список всех баз данных.
r.db_list().run(conn)
Обработка таблиц
table_create
db.table_create(table_name[, options]) → object r.table_create(table_name[, options]) → object
Создайте таблицу. Таблица RethinkDB — это набор JSON-документов.
Пример: Создайте таблицу с именем ‘dc_universe’ с настройками по умолчанию.
r.db('heroes').table_create('dc_universe').run(conn)
{
"config_changes": [
{
"new_val": {
"db": "test",
"durability": "hard",
"id": "20ea60d4-3b76-4817-8828-98a236df0297",
"name": "dc_universe",
"primary_key": "id",
"shards": [
{
"primary_replica": "rethinkdb_srv1",
"replicas": [
"rethinkdb_srv1",
"rethinkdb_srv2"
]
}
],
"write_acks": "majority"
},
"old_val": None
}
],
"tables_created": 1
}
table_drop
db.table_drop(table_name) → object
Удалите таблицу. Таблица и все данные в ней будут удалены.
Пример: Удалите таблицу с именем ‘dc_universe’.
r.db('test').table_drop('dc_universe').run(conn)
{
"config_changes": [
{
"old_val": {
"db": "test",
"durability": "hard",
"id": "20ea60d4-3b76-4817-8828-98a236df0297",
"name": "dc_universe",
"primary_key": "id",
"shards": [
{
"primary_replica": "rethinkdb_srv1",
"replicas": [
"rethinkdb_srv1",
"rethinkdb_srv2"
]
}
],
"write_acks": "majority"
},
"new_val": None
}
],
"tables_dropped": 1
}
table_list
db.table_list() → array
Список всех имён таблиц в базе данных. Результатом является список строк.
Пример: Список всех таблиц в базе данных ‘test’.
r.db('test').table_list().run(conn)
index_create
table.index_create(index_name[, index_function][, multi=False, geo=False]) → object
Создайте новый вторичный индекс в таблице. Вторичные индексы повышают скорость многих запросов на чтение с небольшой потерей места в хранилище и снижением производительности записи. Для получения дополнительной информации о вторичных индексах прочитайте статью «Использование вторичных индексов в RethinkDB».
Пример: Создайте простой индекс, основанный на поле post_id.
r.table('comments').index_create('post_id').run(conn)
index_drop
table.index_drop(index_name) → object
Удалить ранее созданный вторичный индекс этой таблицы.
Пример: Удалить вторичный индекс с именем ‘code_name’.
r.table('dc').index_drop('code_name').run(conn)
index_list
table.index_list() → array
Список всех вторичных индексов этой таблицы.
Пример: Список доступных вторичных индексов для этой таблицы.
r.table('marvel').index_list().run(conn)
index_rename
table.index_rename(old_index_name, new_index_name[, overwrite=False]) → object
Переименовать существующий вторичный индекс в таблице. Если необязательный аргумент overwrite задан как True, ранее существовавший индекс с новым именем будет удалён, и индекс будет переименован. Если overwrite равно False (по умолчанию), произойдёт ошибка, если индекс с новым именем уже существует.
Пример: Переименование индекса в таблице комментариев.
r.table('comments').index_rename('post_id', 'message_id').run(conn)
index_status
table.index_status([, index...]) → array
Получить статус указанных индексов в этой таблице или статус всех индексов в этой таблице, если индексы не указаны.
Пример: Получить статус всех индексов в test:
r.table('test').index_status().run(conn)
index_wait
table.index_wait([, index...]) → array
Дождаться готовности указанных индексов в этой таблице или готовности всех индексов в этой таблице, если индексы не указаны.
Пример: Дождаться готовности всех индексов в таблице test:
r.table('test').index_wait().run(conn)
[set_write_hook(set_write_hook/)
table.set_write_hook(function | binary | null) → object
Устанавливает обработчик записи в таблице или перезаписывает его, если он уже существует.
Обработчик записи может быть анонимной функцией с сигнатурой (context: object, old_val: object, new_val: object) -> object или двоичным представлением, полученным из поля function из get_write_hook. Функция должна быть детерминированной и не может использовать подзапрос или команду r.js.
getWriteHook
table.get_write_hook() → null/object
Получить обработчик записи для этой таблицы. Если обработчик записи существует, результат — объект следующего формата:
{
"function": <binary>,
"query": "setWriteHook(function(_var1, _var2, _var3) { return ...; })",
}
Запись данных
insert
table.insert(object | [object1, object2, ...][, durability="hard", return_changes=False, conflict="error"]) → object
Вставить документы в таблицу. Принимает один документ или массив документов.
Пример: Вставка документа в таблицу posts.
r.table("posts").insert({
"id": 1,
"title": "Lorem ipsum",
"content": "Dolor sit amet"
}).run(conn)
update
table.update(object | function[, durability="hard", return_changes=False, non_atomic=False]) → object selection.update(object | function[, durability="hard", return_changes=False, non_atomic=False]) → object singleSelection.update(object | function[, durability="hard", return_changes=False, non_atomic=False]) → object
Обновить JSON-документы в таблице. Принимает JSON-документ, выражение ReQL или их комбинацию.
Пример: Обновить статус записи с id от 1 до published.
r.table("posts").get(1).update({"status": "published"}).run(conn)
replace
table.replace(object | function[, durability="hard", return_changes=False, non_atomic=False]) → object selection.replace(object | function[, durability="hard", return_changes=False, non_atomic=False]) → object singleSelection.replace(object | function[, durability="hard", return_changes=False, non_atomic=False]) → object
Заменить документы в таблице. Принимает JSON-документ или выражение ReQL и заменяет исходный документ новым. Новый документ должен иметь тот же первичный ключ, что и исходный.
Пример: Заменить документ с первичным ключом 1.
r.table("posts").get(1).replace({
"id": 1,
"title": "Lorem ipsum",
"content": "Aleas jacta est",
"status": "draft"
}).run(conn)
delete
table.delete([durability="hard", return_changes=False]) → object selection.delete([durability="hard", return_changes=False]) → object singleSelection.delete([durability="hard", return_changes=False]) → object
Удалить один или несколько документов из таблицы.
Пример: Удалить один документ из таблицы comments.
r.table("comments").get("7eab9e63-73f1-4f33-8ce4-95cbea626f59").delete().run(conn)
sync
table.sync() → object
sync гарантирует, что записи в заданной таблице записываются в постоянное хранилище. Запросы, которые задают мягкую устойчивость (durability='soft'), не дают таких гарантий, поэтому sync можно использовать для обеспечения состояния этих запросов. Вызов sync не возвращает результат, пока все предыдущие записи в таблицу не будут сохранены.
Пример: После обновления нескольких героев с мягкой устойчивостью мы теперь хотим подождать, пока эти изменения не будут сохранены.
r.table('marvel').sync().run(conn)
Выбор данных
db
r.db(db_name) → db
Ссылка на базу данных.
Пример: Явно указывается база данных для запроса.
r.db('heroes').table('marvel').run(conn)
table
db.table(name[, read_mode='single', identifier_format='name']) → table
Возвращает все документы в таблице. После этой команды можно применить другие команды table, чтобы вернуть подмножество документов (такие как get и filter) или выполнить дальнейшую обработку.
Пример: Возвращает все документы в таблице ‘marvel’ из базы данных по умолчанию.
r.table('marvel').run(conn)
get
table.get(key) → singleRowSelection
Получение документа по первичному ключу.
Пример: Нахождение документа по UUID.
r.table('posts').get('a9849eef-7176-4411-935b-79a6e3c56a74').run(conn)
get_all
table.get_all([key1, key2...], [, index='id']) → selection
Получение всех документов, где заданное значение совпадает со значением запрошенного индекса.
Пример: Ключи вторичных индексов не гарантированно уникальны, поэтому для запроса при использовании вторичного индекса нельзя использовать get.
r.table('marvel').get_all('man_of_steel', index='code_name').run(conn)
between
table.between(lower_key, upper_key[, options]) → table_slice table_slice.between(lower_key, upper_key[, options]) → table_slice
Получение всех документов между двумя ключами. Принимает три необязательных аргумента: index, left_bound, и right_bound. Если index установлено в имя вторичного индекса, between вернет все документы, где значение этого индекса находится в указанном диапазоне (по умолчанию используется первичный ключ). left_bound или right_bound можно установить в open или closed, чтобы указать, включать или не включать конец диапазона (по умолчанию left_bound закрыт, а right_bound открыт).
Пример: Найти всех пользователей с первичным ключом ≥ 10 и < 20 (обычный полуоткрытый интервал).
r.table('marvel').between(10, 20).run(conn)
filter
selection.filter(predicate_function[, default=False]) → selection stream.filter(predicate_function[, default=False]) → stream array.filter(predicate_function[, default=False]) → array
Возвращает все элементы в последовательности, для которых заданное предикат истинно. Результат filter будет таким же, как и входные данные (последовательность, поток или массив). Документы могут быть отфильтрованы различными способами — диапазоны, вложенные значения, булевы условия и результаты анонимных функций.
Пример: Получить всех пользователей, которым 30 лет.
r.table('users').filter({'age': 30}).run(conn)
Предикат {'age': 30} выбирает документы в таблице users с полем age, значение которого 30. Документы с полем age с любым другим значением или без поля age пропускаются.
Объединения
inner_join
sequence.inner_join(other_sequence, predicate_function) → stream array.inner_join(other_sequence, predicate_function) → array
Возвращает внутреннее объединение двух последовательностей.
Пример: Возвращает список всех противостояний между героями Marvel и DC, в которых герой DC мог бы победить героя Marvel в бою.
r.table('marvel').inner_join(r.table('dc'),
lambda marvel_row, dc_row: marvel_row['strength'] < dc_row['strength']
).zip().run(conn)
outer_join
sequence.outer_join(other_sequence, predicate_function) → stream array.outer_join(other_sequence, predicate_function) → array
Возвращает левое внешнее объединение двух последовательностей. Полученная последовательность представляет собой объединение левой и правой последовательностей: все документы из левой последовательности будут возвращены, каждый сопоставлен с документом в правой последовательности, если он удовлетворяет условиям предиката. В большинстве случаев вам потребуется после объединения использовать zip для объединения левых и правых результатов.
Пример: Возвращает список всех героев Marvel, сопоставленных с любыми героями DC, которые могли бы их победить в бою.
r.table('marvel').outer_join(r.table('dc'),
lambda marvel_row, dc_row: marvel_row['strength'] < dc_row['strength']
).zip().run(conn)
(Сравните это с inner_join с теми же входными данными и предикатом, который вернет список только тех противостояний, в которых у героя DC выше сила.)
eq_join
sequence.eq_join(left_field, right_table[, index='id', ordered=False]) → sequence sequence.eq_join(function, right_table[, index='id', ordered=False]) → sequence
Объединение таблиц с использованием поля или функции в левой последовательности, сопоставляющей первичные ключи или вторичные индексы в правой таблице. eq_join более эффективен, чем другие типы объединений ReQL, и работает намного быстрее. Документы в наборе результатов представляют собой пары документов из левой и правой таблиц, сопоставленные, когда поле в левой стороне существует и не является пустым, и существует запись со значением этого поля в указанном индексе в правой стороне.
Пример: Сопоставление игроков с играми, в которых они играли друг против друга.
Объедините эти таблицы с использованием game_id в таблице игроков и id в таблице игр:
r.table('players').eq_join('game_id', r.table('games')).run(conn)
Это вернёт набор результатов, например, следующий:
[
{
"left" : { "game_id" : 3, "id" : 2, "player" : "Agatha" },
"right" : { "id" : 3, "field" : "Bucklebury" }
},
{
"left" : { "game_id" : 2, "id" : 3, "player" : "Fred" },
"right" : { "id" : 2, "field" : "Rushock Bog" }
},
...
]
zip
stream.zip() → stream array.zip() → array
Используется для «сжатия» результата объединения путем объединения полей «правый» в поля «левый» каждого члена последовательности.
Пример: «Сжимает» последовательность, объединяя левые и правые поля, полученные в результате объединения.
r.table('marvel').eq_join('main_dc_collaborator', r.table('dc')).zip().run(conn)
Преобразования
map
sequence1.map([sequence2, ...], function) → stream array1.map([array2, ...], function) → array r.map(sequence1[, sequence2, ...], function) → stream r.map(array1[, array2, ...], function) → array
Преобразует каждый элемент одного или нескольких последовательностей, применяя к ним функцию отображения. Если map выполняется с двумя или более последовательностями, она будет итерироваться по столько элементов, сколько их в самой короткой последовательности.
Пример: Возвращает первые пять квадратов.
> r.expr([1, 2, 3, 4, 5]).map(lambda val: (val * val)).run(conn)
[1, 4, 9, 16, 25]
with_fields
sequence.with_fields([selector1, selector2...]) → stream array.with_fields([selector1, selector2...]) → array
Извлекает один или несколько атрибутов из последовательности объектов, отфильтровывая любые объекты в последовательности, у которых отсутствуют указанные поля. Функционально это идентично has_fields, за которым следует pluck над последовательностью.
Пример: Получить список пользователей и их постов, исключая пользователей, которые не сделали ни одного поста.
Структура существующей таблицы:
[
{ 'id': 1, 'user': 'bob', 'email': 'bob@foo.com', 'posts': [ 1, 4, 5 ] },
{ 'id': 2, 'user': 'george', 'email': 'george@foo.com' },
{ 'id': 3, 'user': 'jane', 'email': 'jane@foo.com', 'posts': [ 2, 3, 6 ] }
]
Команда и вывод:
r.table('users').with_fields('id', 'user', 'posts').run(conn)
[
{ 'id': 1, 'user': 'bob', 'posts': [ 1, 4, 5 ] },
{ 'id': 3, 'user': 'jane', 'posts': [ 2, 3, 6 ] }
]
concat_map
stream.concat_map(function) → stream array.concat_map(function) → array
Объединяет один или несколько элементов в одну последовательность, используя функцию отображения.
Пример: Создать последовательность всех монстров, побеждённых героями Marvel. Поле “defeatedMonsters” представляет собой массив из одного или нескольких имён монстров.
r.table('marvel').concat_map(lambda hero: hero['defeatedMonsters']).run(conn)
order_by
table.order_by([key | function], index=index_name) → table_slice selection.order_by(key | function[, ...]) → selection<array> sequence.order_by(key | function[, ...]) → array
Сортирует последовательность по значениям документов заданного ключа(ей). Для указания порядка оберните атрибут либо r.asc , либо r.desc (по умолчанию возрастание).
Пример: Отсортировать все посты по индексу date.
r.table('posts').order_by(index='date').run(conn)
skip
sequence.skip(n) → stream array.skip(n) → array
Пропускает заданное количество элементов с начала последовательности.
Пример: Здесь, в сочетании с order_by, мы выбираем проигнорировать самых успешных героев.
r.table('marvel').order_by('successMetric').skip(10).run(conn)
limit
sequence.limit(n) → stream array.limit(n) → array
Останавливает последовательность после заданного количества элементов.
Пример: В наш Пантеон героев поместятся только определённое количество.
r.table('marvel').order_by('belovedness').limit(10).run(conn)
slice, []
selection.slice(start_offset[, end_offset, left_bound='closed', right_bound='open']) → selection stream.slice(start_offset[, end_offset, left_bound='closed', right_bound='open']) → stream array.slice(start_offset[, end_offset, left_bound='closed', right_bound='open']) → array binary.slice(start_offset[, end_offset, left_bound='closed', right_bound='open']) → binary string.slice(start_offset[, end_offset, left_bound='closed', right_bound='open']) → string
Возвращает элементы последовательности в заданном диапазоне.
Пример: Возвратить четвёртого, пятого и шестого самых молодых игроков. (Самый молодой игрок имеет индекс 0, поэтому это элементы 3–5.)
r.table('players').order_by(index='age').slice(3,6).run(conn)
Или, используя оператор среза Python:
r.table('players').filter({'class': 'amateur'})[10:20].run(conn)
nth
sequence.nth(index) → object selection.nth(index) → selection<object>
Получает n-ый элемент последовательности, считая с нуля. Если аргумент отрицательный, считает с последнего элемента.
Пример: Выберите второй элемент в массиве.
r.expr([1,2,3]).nth(1).run(conn)
r.expr([1,2,3])[1].run(conn)
offsets_of
sequence.offsets_of(datum | predicate_function) → array
Получает индексы элемента в последовательности. Если аргумент является предикатом, получает индексы всех элементов, соответствующих ему.
Пример: Найдите позицию буквы ‘c’.
r.expr(['a','b','c']).offsets_of('c').run(conn)
is_empty
sequence.is_empty() → bool
Проверяет, пуста ли последовательность.
Пример: Есть ли какие-либо документы в таблице marvel?
r.table('marvel').is_empty().run(conn)
union
stream.union(sequence[, sequence, ...][, interleave=True]) → stream array.union(sequence[, sequence, ...][, interleave=True]) → array r.union(stream, sequence[, sequence, ...][, interleave=True]) → stream r.union(array, sequence[, sequence, ...][, interleave=True]) → array
Объединяет две или более последовательности.
Пример: Создать поток всех героев.
r.table('marvel').union(r.table('dc')).run(conn)
sample
sequence.sample(number) → selection stream.sample(number) → array array.sample(number) → array
Выбирает заданное количество элементов из последовательности с равномерным случайным распределением. Выбор осуществляется без возвращения.
Пример: Выберите 3 случайных героя.
r.table('marvel').sample(3).run(conn)
Агрегирование
group
sequence.group(field | function..., [index=<indexname>, multi=False]) → grouped_stream r.group(sequence, field | function..., [index=<indexname>, multi=False]) → grouped_stream
Принимает поток и разбивает его на несколько групп на основе заданных полей или функций.
Пример: Группировка игр по игрокам.
> r.table('games').group('player').run(conn)
{
"Alice": [
{"id": 5, "player": "Alice", "points": 7, "type": "free"},
{"id": 12, "player": "Alice", "points": 2, "type": "free"}
],
"Bob": [
{"id": 2, "player": "Bob", "points": 15, "type": "ranked"},
{"id": 11, "player": "Bob", "points": 10, "type": "free"}
]
}
ungroup
grouped_stream.ungroup() → array grouped_data.ungroup() → array
Принимает сгруппированный поток или данные и преобразует их в массив объектов, представляющих группы. Любые команды, присоединенные после ungroup , будут работать с этим массивом, а не с каждой группой индивидуально. Это полезно, если вы хотите, например, отсортировать группы по значению их сворачивания.
Пример: Каково максимальное количество очков, набранных каждым игроком, с лучшими результатами вначале?
r.table('games')
.group('player').max('points')['points']
.ungroup().order_by(r.desc('reduction')).run(conn)
reduce
sequence.reduce(function) → value r.reduce(sequence, function) → value
Производит одно значение из последовательности путем многократного применения функции сокращения.
Пример: Возвращает количество документов в таблице posts.
r.table("posts").map(lambda doc: 1)
.reduce(lambda left, right: left+right)
.default(0).run(conn)
Более короткий способ выполнения этого запроса — использование count.
fold
sequence.fold(base, function) → value sequence.fold(base, function, emit=function[, final_emit=function]) → sequence
Применяет функцию к последовательности по порядку, сохраняя состояние через аккумулятор. Команда fold возвращает либо одно значение, либо новую последовательность.
Пример: Объединение слов из списка.
r.table('words').order_by('id').fold('',
lambda acc, word: acc + r.branch(acc == '', '', ', ') + word
).run(conn)
(Этот пример можно реализовать с помощью reduce, но fold сохранит порядок, когда words является таблицей RethinkDB или другим потоком, что не гарантируется с reduce.)
count
sequence.count([value | predicate_function]) → number binary.count() → number string.count() → number object.count() → number r.count(sequence | binary | string | object[, predicate_function]) → number
Подсчитывает количество элементов в последовательности или пар ключ/значение в объекте, или возвращает размер строки или двоичного объекта.
Пример: Подсчет количества пользователей.
r.table('users').count().run(conn)
sum
sequence.sum([field | function]) → number r.sum(sequence, [field | function]) → number
Суммирует все элементы последовательности. Если вызывается с именем поля, суммирует все значения этого поля в последовательности, пропуская элементы последовательности, которым не хватает этого поля. Если вызывается с функцией, вызывает эту функцию для каждого элемента последовательности и суммирует результаты, пропуская элементы последовательности, где эта функция возвращает None или ошибку отсутствия.
Пример: Что такое 3 + 5 + 7?
r.expr([3, 5, 7]).sum().run(conn)
avg
sequence.avg([field | function]) → number r.avg(sequence, [field | function]) → number
Вычисляет среднее значение всех элементов последовательности. Если вызывается с именем поля, вычисляет среднее значение всех значений этого поля в последовательности, пропуская элементы последовательности, которым не хватает этого поля. Если вызывается с функцией, вызывает эту функцию для каждого элемента последовательности и вычисляет среднее значение результатов, пропуская элементы последовательности, где эта функция возвращает None или ошибку отсутствия.
Пример: Каково среднее значение 3, 5 и 7?
r.expr([3, 5, 7]).avg().run(conn)
min
sequence.min(field | function) → element sequence.min(index=<indexname>) → element r.min(sequence, field | function) → element r.min(sequence, index=<indexname>) → element
Находит минимальный элемент последовательности.
Пример: Вернуть минимальное значение в списке [3, 5, 7].
r.expr([3, 5, 7]).min().run(conn)
max
sequence.max(field | function) → element sequence.max(index=<indexname>) → element r.max(sequence, field | function) → element r.max(sequence, index=<indexname>) → element
Находит максимальный элемент последовательности.
Пример: Вернуть максимальное значение в списке [3, 5, 7].
r.expr([3, 5, 7]).max().run(conn)
distinct
sequence.distinct() → array table.distinct([index=<indexname>]) → stream r.distinct(sequence) → array r.distinct(table, [index=<indexname>]) → stream
Удаляет дубликаты элементов из последовательности.
Пример: Какие уникальные злодеи были побеждены героями Marvel?
r.table('marvel').concat_map(
lambda hero: hero['villain_list']).distinct().run(conn)
contains
sequence.contains([value | predicate_function, ...]) → bool r.contains(sequence, [value | predicate_function, ...]) → bool
При вызове со значениями, возвращает True если последовательность содержит все указанные значения. При вызове с предикатными функциями, возвращает True если для каждого предиката существует по крайней мере один элемент потока, где этот предикат возвращает True.
Пример: Иронмен когда-либо сражался с Суперменом?
r.table('marvel').get('ironman')['opponents'].contains('superman').run(conn)
Обработка документов
row
r.row → value
Возвращает текущий посещаемый документ.
Пример: Получить всех пользователей, чей возраст больше 5.
r.table('users').filter(r.row['age'] > 5).run(conn)
pluck
sequence.pluck([selector1, selector2...]) → stream array.pluck([selector1, selector2...]) → array object.pluck([selector1, selector2...]) → object singleSelection.pluck([selector1, selector2...]) → object
Извлекает одно или несколько атрибутов из объекта или последовательности объектов (проекция).
Пример: Нам нужна только информация о реакторе Железного человека, а не весь остальной документ.
r.table('marvel').get('IronMan').pluck('reactorState', 'reactorPower').run(conn)
without
sequence.without([selector1, selector2...]) → stream array.without([selector1, selector2...]) → array singleSelection.without([selector1, selector2...]) → object object.without([selector1, selector2...]) → object
Обратное pluck; принимает объект или последовательность объектов и возвращает их с удаленными указанными путями.
Пример: Поскольку нам это не нужно для этого вычисления, мы сэкономим пропускную способность и оставим список любовных увлечений Железного человека.
r.table('marvel').get('IronMan').without('personalVictoriesList').run(conn)
merge
singleSelection.merge([object | function, object | function, ...]) → object object.merge([object | function, object | function, ...]) → object sequence.merge([object | function, object | function, ...]) → stream array.merge([object | function, object | function, ...]) → array
Объединяет два или более объекта для создания нового объекта со свойствами всех объектов. При конфликте имён полей предпочтение отдаётся полям в правом объекте в списке аргументов merge также принимает функцию подзапроса, возвращающую объект, которая будет использоваться аналогично функции map.
Пример: Подготовить Тора к битве.
r.table('marvel').get('thor').merge(
r.table('equipment').get('hammer'),
r.table('equipment').get('pimento_sandwich')
).run(conn)
append
array.append(value) → array
Добавляет значение в массив.
Пример: Получить список снаряжения Железного человека с добавлением новых ботинок.
r.table('marvel').get('IronMan')['equipment'].append('newBoots').run(conn)
prepend
array.prepend(value) → array
Добавляет значение в начало массива.
Пример: Получить список снаряжения Железного человека с добавлением новых ботинок.
r.table('marvel').get('IronMan')['equipment'].prepend('newBoots').run(conn)
difference
array.difference(array) → array
Удаляет элементы одного массива из другого массива.
Пример: Получить список снаряжения Железного человека без ботинок.
r.table('marvel').get('IronMan')['equipment'].difference(['Boots']).run(conn)
set_insert
array.set_insert(value) → array
Добавляет значение в массив и возвращает его как множество (массив с уникальными значениями).
Пример: Получить список снаряжения Железного человека с добавлением новых ботинок.
r.table('marvel').get('IronMan')['equipment'].set_insert('newBoots').run(conn)
set_union
array.set_union(array) → array
Добавляет несколько значений в массив и возвращает его как множество (массив с уникальными значениями).
Пример: Получить список снаряжения Железного человека с добавлением новых ботинок и реактора.
r.table('marvel').get('IronMan')['equipment'].set_union(['newBoots', 'arc_reactor']).run(conn)
set_intersection
array.set_intersection(array) → array
Пересекает два массива, возвращая значения, присутствующие в обоих, как множество (массив с уникальными значениями).
Пример: Проверить, какое снаряжение Железный человек имеет из фиксированного списка.
r.table('marvel').get('IronMan')['equipment'].set_intersection(['newBoots', 'arc_reactor']).run(conn)
set_difference
array.set_difference(array) → array
Удаляет элементы одного массива из другого и возвращает их как множество (массив с уникальными значениями).
Пример: Проверить, какое снаряжение Железный человек имеет, исключая фиксированный список.
r.table('marvel').get('IronMan')['equipment'].set_difference(['newBoots', 'arc_reactor']).run(conn)
[] (bracket)
sequence[attr] → sequence singleSelection[attr] → value object[attr] → value array[index] → value
Получает одно поле из объекта. Если вызвана для последовательности, получает это поле из каждого объекта в последовательности, пропускает объекты, у которых этого поля нет.
Пример: Какое было первое появление Железного человека в комиксе?
r.table('marvel').get('IronMan')['firstAppearance'].run(conn)
get_field
sequence.get_field(attr) → sequence singleSelection.get_field(attr) → value object.get_field(attr) → value
Получает одно поле из объекта. Если вызвана для последовательности, получает это поле из каждого объекта в последовательности, пропускает объекты, у которых этого поля нет.
Пример: Какое было первое появление Железного человека в комиксе?
r.table('marvel').get('IronMan').get_field('firstAppearance').run(conn)
has_fields
sequence.has_fields([selector1, selector2...]) → stream array.has_fields([selector1, selector2...]) → array object.has_fields([selector1, selector2...]) → boolean
Проверяет, есть ли у объекта одно или несколько полей. Объект имеет поле, если у него есть этот ключ и ключ имеет ненулевое значение. Например, у объекта {'a': 1,'b': 2,'c': null} есть поля a и b.
Пример: Возвратить игроков, выигравших игры.
r.table('players').has_fields('games_won').run(conn)
insert_at
array.insert_at(offset, value) → array
Вставляет значение в массив по указанному индексу. Возвращает изменённый массив.
Пример: Халк решает присоединиться к Мстителям.
r.expr(["Iron Man", "Spider-Man"]).insert_at(1, "Hulk").run(conn)
splice_at
array.splice_at(offset, array) → array
Вставляет несколько значений в массив по указанному индексу. Возвращает изменённый массив.
Пример: Халк и Тор решают присоединиться к Мстителям.
r.expr(["Iron Man", "Spider-Man"]).splice_at(1, ["Hulk", "Thor"]).run(conn)
delete_at
array.delete_at(offset [,end_offset]) → array
Удаляет один или несколько элементов из массива по указанному индексу. Возвращает изменённый массив. (Примечание: delete_at работает с массивами, а не документами; для удаления документов см. команду delete.)
Пример: Удалить второй элемент массива.
> r.expr(['a','b','c','d','e','f']).delete_at(1).run(conn)
['a', 'c', 'd', 'e', 'f']
change_at
array.change_at(offset, value) → array
Изменяет значение в массиве по указанному индексу. Возвращает изменённый массив.
Пример: Брюс Баннер превращается в Халка.
r.expr(["Iron Man", "Bruce", "Spider-Man"]).change_at(1, "Hulk").run(conn)
keys
singleSelection.keys() → array object.keys() → array
Возвращает массив, содержащий все ключи объекта. Обратите внимание, что ключи будут отсортированы так, как описано в типах данных ReQL (для строк — лексикографически).
Пример: Получить все ключи из строки таблицы.
# row: { "id": 1, "mail": "fred@example.com", "name": "fred" }
r.table('users').get(1).keys().run(conn)
> [ "id", "mail", "name" ]
values
singleSelection.values() → array object.values() → array
Возвращает массив, содержащий все значения объекта. values() гарантирует, что значения будут возвращены в том же порядке, что и у keys.
Пример: Получить все значения из строки таблицы.
# row: { "id": 1, "mail": "fred@example.com", "name": "fred" }
r.table('users').get(1).values().run(conn)
> [ 1, "fred@example.com", "fred" ]
literal
r.literal(object) → special
Заменяет объект в поле вместо слияния его с существующим объектом в операции merge или update. = Использование literal без аргументов в операциях merge или update удалит соответствующее поле.
Пример: Заменить один вложенный документ другим, а не объединять поля.
r.table('users').get(1).update({ 'data': r.literal({ 'age': 19, 'job': 'Engineer' }) }).run(conn)
{
"id": 1,
"name": "Alice",
"data": {
"age": 19,
"job": "Engineer"
}
}
object
r.object([key, value,]...) → object
Создаёт объект из списка пар ключ-значение, где ключи должны быть строками. r.object(A, B, C, D) эквивалентно r.expr([[A, B], [C, D]]).coerce_to('OBJECT').
Пример: Создать простой объект.
> r.object('id', 5, 'data', ['foo', 'bar']).run(conn)
{'data': ["foo", "bar"], 'id': 5}
Обработка строк
match
string.match(regexp) → None/object
Сопоставляет строку с регулярным выражением. Если совпадение найдено, возвращает объект с полями:
-
str: Совпавшая строка -
start: Начало совпавшей строки -
end: Конец совпавшей строки -
groups: Группы захвата, определённые в скобках
Если совпадение не найдено, возвращает None.
Пример: Получить всех пользователей, чьи имена начинаются с «А». Так как None вычисляется в false в filter, можно просто использовать результат match в качестве предиката.
r.table('users').filter(lambda doc:
doc['name'].match("^A")
).run(conn)
split
string.split([separator, [max_splits]]) → array
Разбивает строку на подстроки. Разбивает по пробелам, если вызов не содержит аргументов. Если указан разделитель, разбивает по этому разделителю. Если указан разделитель и максимальное количество разбиений, разбивает по этому разделителю не более max_splits раз. (Можно использовать None в качестве разделителя, чтобы разбивать по пробелам, при этом всё ещё задавая max_splits.)
Пример: Разбить по пробелам.
> r.expr("foo bar bax").split().run(conn)
["foo", "bar", "bax"]
upcase
string.upcase() → string
Преобразует строку в верхний регистр.
Пример:
> r.expr("Sentence about LaTeX.").upcase().run(conn)
"SENTENCE ABOUT LATEX."
Примечание: upcase и downcase влияют только на символы ASCII.
downcase
string.downcase() → string
Преобразует строку в нижний регистр.
Пример:
> r.expr("Sentence about LaTeX.").downcase().run(conn)
"sentence about latex."
Примечание: upcase и downcase влияют только на символы ASCII.
Математика и логика
+
value + value → value time + number → time value.add(value[, value, ...]) → value time.add(number[, number, ...]) → time
Сложить два или более чисел или конкатенировать две или более строки или массивы.
Пример: Это так же просто, как 2 + 2 = 4.
> (r.expr(2) + 2).run(conn)
4
-
number - number → number time - number → time time - time → number number.sub(number[, number, ...]) → number time.sub(number[, number, ...]) → time time.sub(time) → number
Вычесть два числа.
Пример: Это так же просто, как 2 - 2 = 0.
(r.expr(2) - 2).run(conn)
*
number * number → number array * number → array number.mul(number[, number, ...]) → number array.mul(number[, number, ...]) → array
Перемножить два числа или создать периодический массив.
Пример: Это так же просто, как 2 * 2 = 4.
(r.expr(2) * 2).run(conn)
/
number / number → number number.div(number[, number ...]) → number
Разделить два числа.
Пример: Это так же просто, как 2 / 2 = 1.
(r.expr(2) / 2).run(conn)
%
number % number → number
Найти остаток от деления двух чисел.
Пример: Это так же просто, как 2 % 2 = 0.
(r.expr(2) % 2).run(conn)
&, and_
bool & bool → bool bool.and_([bool, bool, ...]) → bool r.and_([bool, bool, ...]) → bool
Вычислить логическое «и» одного или нескольких значений.
Пример: Вернуть, истинно ли a и b.
> a = True
> b = False
> (r.expr(a) & b).run(conn)
False
|, or_
bool | bool → bool bool.or_([bool, bool, ...]) → bool r.or_([bool, bool, ...]) → bool
Вычислить логическое «или» одного или нескольких значений.
Пример: Вернуть, истинно ли либо a , либо b.
> a = True
> b = False
> (r.expr(a) | b).run(conn)
True
==, eq
value.eq(value[, value, ...]) → bool value == value → bool
Проверить, равны ли два или более значения.
Пример: Проверить, установлено ли поле role пользователя на значение administrator.
r.table('users').get(1)['role'].eq('administrator').run(conn)
# alternative syntax
(r.table('users').get(1)['role'] == 'administrator').run(conn)
!=, ne
value.ne(value[, value, ...]) → bool value != value → bool
Проверить, не равны ли два или более значения.
Пример: Проверить, не установлено ли поле role пользователя на значение administrator.
r.table('users').get(1)['role'].ne('administrator').run(conn)
# alternative syntax
(r.table('users').get(1)['role'] != 'administrator').run(conn)
>, gt
value.gt(value[, value, ...]) → bool value > value → bool
Сравнить значения, проверяя, больше ли левое значение правого.
Пример: Проверить, набрал ли игрок больше 10 очков.
r.table('players').get(1)['score'].gt(10).run(conn)
# alternative syntax
(r.table('players').get(1)['score'] > 10).run(conn)
>=, ge
value.ge(value[, value, ...]) → bool value >= value → bool
Сравнить значения, проверяя, больше или равно ли левое значение правому.
Пример: Проверить, набрал ли игрок 10 или более очков.
r.table('players').get(1)['score'].ge(10).run(conn)
# alternative syntax
(r.table('players').get(1)['score'] >= 10).run(conn)
<, lt
value.lt(value[, value, ...]) → bool value < value → bool
Сравнить значения, проверяя, меньше ли левое значение правого.
Пример: Проверить, набрал ли игрок меньше 10 очков.
r.table('players').get(1)['score'].lt(10).run(conn)
# alternative syntax
(r.table('players').get(1)['score'] < 10).run(conn)
<=, le
value.le(value[, value, ...]) → bool value <= value → bool
Сравнить значения, проверяя, меньше или равно ли левое значение правому.
Пример: Проверить, набрал ли игрок 10 или меньше очков.
r.table('players').get(1)['score'].le(10).run(conn)
# alternative syntax
(r.table('players').get(1)['score'] <= 10).run(conn)
~, not_
bool.not_() → bool not_(bool) → bool (~bool) → bool
Вычислить логическое отрицание (не) выражения.
Пример: Не истинно — ложно.
r.not_(True).run(conn)
r.expr(True).not_().run(conn)
(~r.expr(True)).run(conn)
Эти значения равны false.
Обратите внимание, что при использовании ~ выражение заключено в скобки. Без этого Python вычислит r.expr(True) сначала, а не используя оператор ReQL, и вернёт неправильное значение. (~True вычисляется как -2 в Python.)
bit_and
r.bit_and(number) → number r.bit_and(number[, number, ...]) → number
Вычислить арифметическое «и» одного или нескольких значений. bit_and принимает один или несколько аргументов.
Пример: Вычислить арифметическое «и» 6 и 4.
r.expr(6).bit_and(4).run(conn)
bit_or
r.bit_or(number) → number r.bit_or(number[, number, ...]) → number
Вычислить арифметическое «или» одного или нескольких значений. bit_or принимает один или несколько аргументов.
Пример: Вычислить арифметическое «или» 6 и 4.
r.expr(6).bit_or(4).run(conn)
bit_xor
r.bit_xor(number) → number r.bit_xor(number[, number, ...]) → number
Вычислить арифметическое «исключающее или» одного или нескольких значений. bit_xor принимает один или несколько аргументов.
Пример: Вычислить арифметическое «исключающее или» 6 и 4.
r.expr(6).bit_xor(4).run(conn)
bit_not
r.bit_not() → number
Вычислить арифметическое отрицание (не) выражения. bit_not не принимает аргументов.
Пример: Отрицание арифметического выражения
r.expr(15).bit_not().run(conn)
bit_sal
r.bit_sal(number) → number r.bit_sal(number[, number, ...]) → number
Вычислить арифметический сдвиг влево (левый логический сдвиг) одного или нескольких значений. bit_sal принимает один или несколько аргументов.
Пример: Вычислить арифметический сдвиг влево 5 и 4.
r.expr(5).bit_sal(4).run(conn)
bit_sar
r.bit_sar(number) → number r.bit_sar(number[, number, ...]) → number
Вычислить арифметический сдвиг вправо одного или нескольких значений. bit_sar принимает один или несколько аргументов.
Пример: Вычислить арифметический сдвиг вправо 32 и 3.
r.expr(32).bit_sar(3).run(conn)
random
r.random() → number r.random(number[, number], float=True) → number r.random(integer[, integer]) → integer
Сгенерировать случайное число в заданных (или подразумеваемых) границах. random принимает ноль, одно или два аргумента.
Пример: Сгенерировать случайное число в диапазоне [0,1).
r.random().run(conn)
round
r.round(number) → number number.round() → number
Округляет данное значение до ближайшего целого числа.
Пример: Округлить 12.345 до ближайшего целого.
> r.round(12.345).run(conn)
12.0
Команда round также может быть использована после выражения.
ceil
r.ceil(number) → number number.ceil() → number
Округляет значение вверх, возвращая наименьшее целое значение, большее или равное заданному значению (верхняя граница значения).
Пример: Вернуть верхнюю границу 12.345.
> r.ceil(12.345).run(conn)
13.0
Команда ceil также может быть использована после выражения.
floor
r.floor(number) → number number.floor() → number
Округляет значение вниз, возвращая наибольшее целое значение, меньшее или равное заданному значению (нижняя граница значения).
Пример: Вернуть нижнюю границу 12.345.
> r.floor(12.345).run(conn)
12.0
Команда floor также может быть использована после выражения.
Даты и время
now
r.now() → time
Возвращает объект времени, представляющий текущее время в UTC. Команда now() вычисляется один раз при получении запроса сервером, поэтому несколько экземпляров r.now() всегда будут возвращать одно и то же время внутри запроса.
Пример: Добавить нового пользователя со временем его подписки.
r.table("users").insert({
"name": "John",
"subscription_date": r.now()
}).run(conn)
time
r.time(year, month, day[, hour, minute, second], timezone) → time
Создаёт объект времени для определённого момента времени.
Пример: Обновить дату рождения пользователя «Иоанн» на 3 ноября 1986 года по UTC.
r.table("user").get("John").update({"birthdate": r.time(1986, 11, 3, 'Z')}).run(conn)
epoch_time
r.epoch_time(number) → time
Создаёт объект времени, основанный на секундах с начала эпохи. Первый аргумент — число с плавающей точкой, которое будет округлено до трёх десятичных знаков (точность до миллисекунды).
Пример: Обновить дату рождения пользователя «Иоанн» на 3 ноября 1986 года.
r.table("user").get("John").update({"birthdate": r.epoch_time(531360000)}).run(conn)
iso8601
r.iso8601(string[, default_timezone='']) → time
Создаёт объект времени на основе строки даты и времени ISO 8601 (например, ‘2013-01-01T01:01:01+00:00’). RethinkDB поддерживает все допустимые форматы ISO 8601, кроме форматов дат недели. Подробнее о формате ISO 8601 можно узнать на Wikipedia.
Пример: Обновить время рождения Иоанна.
r.table("user").get("John").update({"birth": r.iso8601('1986-11-03T08:30:00-07:00')}).run(conn)
in_timezone
time.in_timezone(timezone) → time
Возвращает новый объект времени с другим часовым поясом. Время остаётся неизменным, но результаты, возвращаемые методами, такими как hours(), изменятся, так как они учитывают часовой пояс. Аргумент часового пояса должен быть в формате ISO 8601.
Пример: Час дня в Сан-Франциско (UTC/GMT -8, без учета летнего времени).
r.now().in_timezone('-08:00').hours().run(conn)
timezone
time.timezone() → string
Возвращает часовой пояс объекта времени.
Пример: Возвратить всех пользователей в часовом поясе «-07:00».
r.table("users").filter(lambda user:
user["subscriptionDate"].timezone() == "-07:00"
)
during
time.during(start_time, end_time[, left_bound="closed", right_bound="open"]) → bool
Возвращает, находится ли время между двумя другими временами.
Пример: Получить все сообщения, опубликованные между 1 декабря 2013 года (включительно) и 10 декабря 2013 года (исключительно).
r.table("posts").filter(
r.row['date'].during(r.time(2013, 12, 1, "Z"), r.time(2013, 12, 10, "Z"))
).run(conn)
date
time.date() → time
Возвращает новый объект времени, основанный только на дне, месяце и году (то есть, то же самое время в 00:00).
Пример: Получить всех пользователей, чей день рождения сегодня.
r.table("users").filter(lambda user:
user["birthdate"].date() == r.now().date()
).run(conn)
time_of_day
time.time_of_day() → number
Возвращает количество секунд, прошедших с начала дня, хранящегося в объекте времени.
Пример: Получить сообщения, отправленные до полудня.
r.table("posts").filter(
r.row["date"].time_of_day() <= 12*60*60
).run(conn)
year
time.year() → number
Возвращает год объекта времени.
Пример: Получить всех пользователей, родившихся в 1986 году.
r.table("users").filter(lambda user:
user["birthdate"].year() == 1986
).run(conn)
month
time.month() → number
Возвращает месяц объекта времени как число от 1 до 12. Для удобства определены термины r.january, r.february и т.д., которые сопоставляются с соответствующими целыми числами.
Пример: Получить всех пользователей, родившихся в ноябре.
r.table("users").filter(
r.row["birthdate"].month() == 11
)
day
time.day() → number
Возвращает день объекта времени как число от 1 до 31.
Пример: Возвратить пользователей, родившихся 24 числа любого месяца.
r.table("users").filter(
r.row["birthdate"].day() == 24
)
day_of_week
time.day_of_week() → number
Возвращает день недели объекта времени как число от 1 до 7 (в соответствии со стандартом ISO 8601). Для удобства определены термины r.monday, r.tuesday и т.д., которые сопоставляются с соответствующими целыми числами.
Пример: Возвратить день недели сегодня.
r.now().day_of_week().run(conn)
day_of_year
time.day_of_year() → number
Возвращает день года объекта времени как число от 1 до 366 (в соответствии со стандартом ISO 8601).
Пример: Получить всех пользователей, родившихся в первый день года.
r.table("users").filter(
r.row["birthdate"].day_of_year() == 1
).run(conn)
hours
time.hours() → number
Возвращает час в объекте времени как число от 0 до 23.
Пример: Возвратить все сообщения, отправленные после полуночи и до 4 утра.
r.table("posts").filter(lambda post:
post["date"].hours() < 4
).run(conn)
minutes
time.minutes() → number
Возвращает минуту в объекте времени как число от 0 до 59.
Пример: Возвратить все сообщения, отправленные в первые 10 минут каждого часа.
r.table("posts").filter(lambda post:
post["date"].minutes() < 10
).run(conn)
seconds
time.seconds() → number
Возвращает секунды в объекте времени как число от 0 до 59.999 (двойная точность).
Пример: Возвратить сообщения, отправленные в первые 30 секунд каждой минуты.
r.table("posts").filter(lambda post:
post["date"].seconds() < 30
).run(conn)
to_iso8601
time.to_iso8601() → string
Преобразует объект времени в строку в формате ISO 8601.
Пример: Возвратить текущее время в формате ISO 8601.
> r.now().to_iso8601().run(conn)
"2015-04-20T18:37:52.690+00:00"
to_epoch_time
time.to_epoch_time() → number
Преобразует объект времени в его эпохальное время.
Пример: Возвратить текущее время в секундах с начала эпохи Unix с точностью до миллисекунды.
r.now().to_epoch_time()
Структуры управления
args
r.args(array) → special
r.args — это специальный термин, используемый для вставки массива аргументов в другой термин. Это полезно, когда вы хотите вызвать вариативный термин, такой как get_all, с набором аргументов, сгенерированных во время выполнения.
Пример: Получить Алису и Боба из таблицы people.
r.table('people').get_all('Alice', 'Bob').run(conn)
# or
r.table('people').get_all(r.args(['Alice', 'Bob'])).run(conn)
binary
r.binary(data) → binary
Инкапсулировать двоичные данные в запросе.
Пример: Сохранить изображение аватара в существующую запись пользователя.
f = open('./default_avatar.png', 'rb')
avatar_image = f.read()
f.close()
r.table('users').get(100).update({'avatar': r.binary(avatar_image)}).run(conn)
do
any.do(function) → any r.do([args]*, function) → any any.do(expr) → any r.do([args]*, expr) → any
Вызвать анонимную функцию, используя значения возврата других команд или запросов ReQL в качестве аргументов.
Пример: Вычислить чистый результат гольфиста в игре.
r.table('players').get('86be93eb-a112-48f5-a829-15b2cb49de1d').do(
lambda player: player['gross_score'] - player['course_handicap']
).run(conn)
branch
r.branch(test, true_action[, test2, test2_action, ...], false_action) → any test.branch(true_action[, test2, test2_action, ...], false_action) → any
Выполнить разветвлённую условную операцию, эквивалентную if-then-else.
Команда branch принимает 2n+1 аргумент: пары условных выражений и команд, которые будут выполнены, если условные выражения вернут любое значение, кроме False или None (т. е. «истинностных» значений), с конечной командой «иначе», которая будет выполнена, если все условные выражения являются False или None.
Пример: Проверить значение x.
x = 10
r.branch((x > 5), 'big', 'small').run(conn)
> "big"
for_each
sequence.for_each(write_function) → object
Перебрать последовательность, оценивая заданный запрос записи для каждого элемента.
Пример: Теперь, когда наши герои победили своих злодеев, мы можем безопасно удалить их из таблицы злодеев.
r.table('marvel').for_each(
lambda hero: r.table('villains').get(hero['villainDefeated']).delete()
).run(conn)
range
r.range() → stream r.range([start_value, ]end_value) → stream
Сгенерировать поток последовательных целых чисел в заданном диапазоне.
Пример: Вернуть диапазон из четырёх элементов [0, 1, 2, 3].
> r.range(4).run(conn)
[0, 1, 2, 3]
error
r.error(message) → error
Выбросить ошибку выполнения. Если вызывается без аргументов внутри второго аргумента default, повторно выбросить текущую ошибку.
Пример: Железный Человек не мог проиграть битву:
r.table('marvel').get('IronMan').do(
lambda ironman: r.branch(ironman['victories'] < ironman['battles'],
r.error('impossible code path'),
ironman)
).run(conn)
default
value.default(default_value | function) → any sequence.default(default_value | function) → any
Предоставить значение по умолчанию в случае ошибок несоответствия. Команда default оценивает свой первый аргумент (значение, к которому она привязана). Если этот аргумент возвращает None или при оценке выбрасывается ошибка несоответствия, то default возвращает свой второй аргумент. Второй аргумент обычно является значением по умолчанию, но может быть функцией, возвращающей значение.
Пример: Получить названия и авторов таблицы posts. В случае отсутствия поля «автор» или None, мы хотим получить строку Anonymous.
r.table("posts").map(lambda post:
{
"title": post["title"],
"author": post["author"].default("Anonymous")
}
).run(conn)
expr
r.expr(value) → value
Создать объект ReQL JSON из объекта нативного языка.
Пример: Объекты, обернутые с помощью expr, могут быть затем обработаны функциями API ReQL.
r.expr({'a':'b'}).merge({'b':[1,2,3]}).run(conn)
js
r.js(js_string[, timeout=<number>]) → value
Создать выражение JavaScript.
Пример: Объединить две строки с использованием JavaScript.
timeout — количество секунд до r.js истекает. Значение по умолчанию — 5 секунд.
Всякий раз, когда это возможно, используйте родные команды ReQL, а не
r.js, для лучшей производительности.
r.js("'str1' + 'str2'").run(conn)
coerce_to
sequence.coerce_to('array') → array
value.coerce_to('string') → string
string.coerce_to('number') → number
array.coerce_to('object') → object
sequence.coerce_to('object') → object
object.coerce_to('array') → array
binary.coerce_to('string') → string
string.coerce_to('binary') → binary
Преобразовать значение одного типа в другой.
Пример: Преобразовать поток в массив, чтобы сохранить его вывод в поле. (Поток напрямую не может быть сохранен в поле.)
r.table('posts').map(lambda post: post.merge(
{ 'comments': r.table('comments').get_all(post['id'], index='post_id').coerce_to('array') }
)).run(conn)
type_of
any.type_of() → string
Получает тип возвращаемого значения запроса ReQL.
Пример: Получить тип строки.
> r.expr("foo").type_of().run(conn)
"STRING"
info
any.info() → object r.info(any) → object
Получить информацию о значении ReQL.
Пример: Получить информацию о таблице, такую как первичный ключ или размер кэша.
r.table('marvel').info().run(conn)
json
r.json(json_string) → value
Разбирает строку JSON на сервере.
Пример: Отправить массив на сервер.
r.json("[1,2,3]").run(conn)
to_json_string, to_json
value.to_json_string() → string value.to_json() → string
Преобразовать значение или объект ReQL в строку JSON. Вы можете использовать либо to_json_string, либо to_json.
Пример: Получить документ ReQL в виде строки JSON.
> r.table('hero').get(1).to_json()
'{"id": 1, "name": "Batman", "city": "Gotham", "powers": ["martial arts", "cinematic entrances"]}'
http
r.http(url[, options]) → value r.http(url[, options]) → stream
Получить данные из указанного URL по протоколу HTTP. Тип возвращаемого значения зависит от опции result_format, которая по умолчанию проверяет Content-Type ответа. Убедитесь, что вы никогда не используете эту команду для пользовательских URL.
Пример: Выполнить HTTP GET и сохранить результат в таблице.
r.table('posts').insert(r.http('http://httpbin.org/get')).run(conn)
uuid
r.uuid([string]) → string
Возвращает UUID (универсальный уникальный идентификатор), строку, которая может использоваться в качестве уникального идентификатора. Если строка передаётся в uuid в качестве аргумента, UUID будет детерминированным, полученным из хэша SHA-1 строки.
Пример: Сгенерировать UUID.
> r.uuid().run(conn)
"27961a0e-f4e8-4eb3-bf95-c5203e1d87b9"
Географические команды
circle
r.circle([longitude, latitude], radius[, num_vertices=32, geo_system='WGS84', unit='m', fill=True]) → geometry
r.circle(point, radius[, {num_vertices=32, geo_system='WGS84', unit='m', fill=True]) → geometry
Создаёт круговую линию или многоугольник. Окружность в RethinkDB представляет собой многоугольник или линию, приближающую окружность заданного радиуса вокруг заданного центра, состоящую из заданного количества вершин (по умолчанию 32).
Пример: Определение окружности.
r.table('geo').insert({
'id': 300,
'name': 'Hayes Valley',
'neighborhood': r.circle([-122.423246, 37.779388], 1000)
}).run(conn)
distance
geometry.distance(geometry[, geo_system='WGS84', unit='m']) → number r.distance(geometry, geometry[, geo_system='WGS84', unit='m']) → number
Вычисляет расстояние между точкой и другим геометрическим объектом. По крайней мере, один из указанных геометрических объектов должен быть точкой.
Пример: Вычисление расстояния между двумя точками на Земле в километрах.
> point1 = r.point(-122.423246, 37.779388)
> point2 = r.point(-117.220406, 32.719464)
> r.distance(point1, point2, unit='km').run(conn)
734.1252496021841
fill
line.fill() → polygon
Преобразует объект типа Line в объект типа Polygon. Если последняя точка не имеет тех же координат, что и первая точка, polygon закроет многоугольник, соединив их.
Пример: Создание объекта типа линия и его преобразование в многоугольник.
r.table('geo').insert({
'id': 201,
'rectangle': r.line(
[-122.423246, 37.779388],
[-122.423246, 37.329898],
[-121.886420, 37.329898],
[-121.886420, 37.779388]
)
}).run(conn)
r.table('geo').get(201).update({
'rectangle': r.row['rectangle'].fill()
}, non_atomic=True).run(conn)
geojson
r.geojson(geojson) → geometry
Преобразует объект GeoJSON в геометрический объект ReQL.
Пример: Преобразование объекта GeoJSON в геометрический объект ReQL.
geo_json = {
'type': 'Point',
'coordinates': [ -122.423246, 37.779388 ]
}
r.table('geo').insert({
'id': 'sfo',
'name': 'San Francisco',
'location': r.geojson(geo_json)
}).run(conn)
to_geojson
geometry.to_geojson() → object
Преобразует геометрический объект ReQL в объект GeoJSON.
Пример: Преобразование геометрического объекта ReQL в объект GeoJSON.
> r.table('geo').get('sfo')['location'].to_geojson().run(conn)
{
'type': 'Point',
'coordinates': [ -122.423246, 37.779388 ]
}
get_intersecting
table.get_intersecting(geometry, index='indexname') → selection<stream>
Возвращает все документы, где заданный геометрический объект пересекается с геометрическим объектом запрошенного геопространственного индекса.
Пример: Какие из мест в списке парков пересекаются с circle1?
circle1 = r.circle([-117.220406, 32.719464], 10, unit='mi')
r.table('parks').get_intersecting(circle1, index='area').run(conn)
get_nearest
table.get_nearest(point, index='indexname'[, max_results=100, max_dist=100000, unit='m', geo_system='WGS84']) → array
Возвращает список документов, ближайших к заданной точке, на основе геопространственного индекса, отсортированных по возрастанию расстояния.
Пример: Возвращает список из 25 ближайших вражеских укрытий к секретной базе.
secret_base = r.point(-122.422876, 37.777128)
r.table('hideouts').get_nearest(secret_base, index='location',
max_results=25).run(conn)
includes
sequence.includes(geometry) → sequence geometry.includes(geometry) → bool
Проверяет, полностью ли один геометрический объект содержится в другом. При применении к последовательности геометрических объектов, includes действует как фильтр, возвращая последовательность объектов из последовательности, которые включают аргумент.
Пример: Включается ли point2 в окружность радиусом 2000 метров вокруг point1?
> point1 = r.point(-117.220406, 32.719464)
> point2 = r.point(-117.206201, 32.725186)
> r.circle(point1, 2000).includes(point2).run(conn)
True
intersects
sequence.intersects(geometry) → sequence geometry.intersects(geometry) → bool r.intersects(sequence, geometry) → sequence r.intersects(geometry, geometry) → bool
Проверяет, пересекаются ли два геометрических объекта. При применении к последовательности геометрических объектов, intersects действует как фильтр, возвращая последовательность объектов из последовательности, которые пересекаются с аргументом.
Пример: Находится ли point2 в пределах круга радиусом 2000 метров вокруг point1?
> point1 = r.point(-117.220406, 32.719464)
> point2 = r.point(-117.206201, 32.725186)
> r.circle(point1, 2000).intersects(point2).run(conn)
True
line
r.line([lon1, lat1], [lon2, lat2], ...) → line r.line(point1, point2, ...) → line
Создаёт геометрический объект типа Line. Линия может быть задана двумя способами:
- Два или более массивов из двух элементов, определяющих широту и долготу вершин линии;
- Два или более объекта Point, определяющих вершины линии.
Пример: Определение линии.
r.table('geo').insert({
'id': 101,
'route': r.line([-122.423246, 37.779388], [-121.886420, 37.329898])
}).run(conn)
point
r.point(longitude, latitude) → point
Создаёт геометрический объект типа Point. Точка задаётся двумя числами с плавающей запятой: долготой (−180 до 180) и широтой (−90 до 90) точки на идеальной сфере. См. Поддержку геопространственных данных для получения дополнительной информации о системе координат ReQL.
Пример: Определение точки.
r.table('geo').insert({
'id': 1,
'name': 'San Francisco',
'location': r.point(-122.423246, 37.779388)
}).run(conn)
polygon
r.polygon([lon1, lat1], [lon2, lat2], [lon3, lat3], ...) → polygon r.polygon(point1, point2, point3, ...) → polygon
Создаёт геометрический объект типа Polygon. Многоугольник может быть задан двумя способами:
- Три или более массивов из двух элементов, определяющих широту и долготу вершин многоугольника;
- Три или более объекта Point, определяющих вершины многоугольника.
Пример: Определение многоугольника.
r.table('geo').insert({
'id': 101,
'rectangle': r.polygon(
[-122.423246, 37.779388],
[-122.423246, 37.329898],
[-121.886420, 37.329898],
[-121.886420, 37.779388]
)
}).run(conn)
polygon_sub
polygon1.polygon_sub(polygon2) → polygon
Используйте polygon2 для «вырезания» отверстия в polygon1. polygon2 должен быть полностью вложен в polygon1 и не должен иметь собственных отверстий (он не должен быть результатом polygon_sub).
Пример: Определение многоугольника с вырезанным отверстием.
outer_polygon = r.polygon(
[-122.4, 37.7],
[-122.4, 37.3],
[-121.8, 37.3],
[-121.8, 37.7]
)
inner_polygon = r.polygon(
[-122.3, 37.4],
[-122.3, 37.6],
[-122.0, 37.6],
[-122.0, 37.4]
)
outer_polygon.polygon_sub(inner_polygon).run(conn)
Администрирование
grant
r.grant("username", {"permission": bool[, ...]}) → object
db.grant("username", {"permission": bool[, ...]}) → object
table.grant("username", {"permission": bool[, ...]}) → object
Предоставляет или отменяет разрешения доступа для учётной записи пользователя, глобально или по базам данных/таблицам.
Пример: Предоставление учётной записи пользователя chatapp прав чтения и записи в базе данных users.
> r.db('users').grant('chatapp', {'read': True, 'write': True}).run(conn)
{
"granted": 1,
"permissions_changes": [
{
"new_val": { "read": true, "write": true },
"old_val": { null }
}
]
config
table.config() → selection<object> database.config() → selection<object>
Запрос (чтение и/или обновление) конфигураций для отдельных таблиц или баз данных.
Пример: Получение конфигурации для таблицы users.
r.table('users').config().run(conn)
rebalance
table.rebalance() → object database.rebalance() → object
Перебалансирует фрагменты таблицы. При вызове на базе данных, все таблицы в этой базе данных будут перебалансированы.
Пример: Перебалансировка таблицы.
r.table('superheroes').rebalance().run(conn)
reconfigure
table.reconfigure(shards=<s>, replicas=<r>[, primary_replica_tag=<t>, dry_run=False, nonvoting_replica_tags=None]) → object database.reconfigure(shards=<s>, replicas=<r>[, primary_replica_tag=<t>, dry_run=False, nonvoting_replica_tags=None]) → object table.reconfigure(emergency_repair=<option>, dry_run=False) → object
Переконфигурирует фрагментацию и репликацию таблицы.
Пример: Переконфигурирование таблицы.
r.table('superheroes').reconfigure(shards=2, replicas=1).run(conn)
status
table.status() → selection<object>
Возвращает состояние таблицы.
Пример: Получение состояния таблицы.
r.table('superheroes').status().run(conn)
wait
table.wait([wait_for='all_replicas_ready', timeout=<sec>]) → object database.wait([wait_for='all_replicas_ready', timeout=<sec>]) → object r.wait(table | database, [wait_for='all_replicas_ready', timeout=<sec>]) → object
Ожидает готовности таблицы или всех таблиц в базе данных. Таблица может быть временно недоступна после создания, перебалансировки или переконфигурации. Команда wait блокируется до тех пор, пока данная таблица (или база данных) не будет полностью обновлена.
Пример: Ожидание готовности таблицы.
r.table('superheroes').wait().run(conn)
{"ready": 1}
© RethinkDB contributors
Licensed under the Creative Commons Attribution-ShareAlike 3.0 Unported License.
https://rethinkdb.com/api/python/
