Справочник команд Ruby ReQL
Ищете документацию для драйвера сообщества?
Найдите страницу проекта для вашего драйвера для получения конкретной документации ReQL.
Доступ к ReQL
r
r → r
Пространство имен ReQL верхнего уровня.
Пример: Настройка пространства имен верхнего уровня.
require 'rethinkdb'
include RethinkDB::Shortcuts
connect
r.connect(opts={}) → connection
Создает новое подключение к серверу базы данных. Принимает следующие параметры:
-
host: хост для подключения (по умолчаниюlocalhost). -
port: порт для подключения (по умолчанию28015). -
db: базу данных по умолчанию (по умолчаниюtest). -
user: учетную запись пользователя для подключения (по умолчаниюadmin). -
password: пароль для учетной записи пользователя для подключения (по умолчанию'', пустой). -
timeout: период ожидания в секундах для открытия подключения (по умолчанию20). -
ssl: хеш параметров для поддержки SSL-соединений (по умолчаниюnil). В настоящее время доступен только один параметр, и если указан параметрssl, этот ключ необходим:-
ca_certs: путь к сертификату CA для SSL.
-
Если подключение не может быть установлено, будет брошено исключение ReqlDriverError.
Пример: Открытие подключения с использованием хоста и порта по умолчанию, указав базу данных по умолчанию.
conn = r.connect(:db => 'marvel')
repl
connection.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 и вывод каждой строки результата.
r.table('marvel').run(conn).each { |x| p x }
changes
stream.changes([options) → stream singleSelection.changes([options]) → stream
Преобразует запрос в поток изменений (changefeed), бесконечный поток объектов, представляющих изменения в результатах запроса по мере их возникновения. Поток изменений может возвращать изменения в таблице или отдельном документе (потоке изменений «точки»). Такие команды, как filter или map, могут использоваться перед командой changes для преобразования или фильтрации вывода, и многие команды, работающие с последовательностями, могут быть объединены после changes.
Пример: Подписка на изменения в таблице.
Начать мониторинг потока изменений в одном клиенте:
r.table('games').changes().run(conn).each{|change| p(change)}
По мере выполнения этих запросов во втором клиенте, первый клиент будет получать и выводить следующие объекты:
> r.table('games').insert({:id => 1}).run(conn)
{:old_val => nil, :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 => nil}
> 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
}
em_run
query.em_run(conn[, options], block) → cursor query.em_run(conn[, options], block) → object
Асинхронное выполнение запроса на подключении с использованием EventMachine. Если запрос возвращает последовательность (включая поток), блок будет вызываться один раз для каждого элемента последовательности. В противном случае блок будет вызываться только один раз со возвращаемым значением.
Пример: возвращение списка пользователей в цикле EventMachine.
EventMachine.run {
r.table('users').order_by(:index => 'username').em_run(conn) { |row|
# do something with returned row data
p row
}
}
Курсоры
next
cursor.next([true])
Получение следующего элемента в курсоре.
Пример: Получение следующего элемента.
cursor = r.table('superheroes').run(conn)
doc = cursor.next()
each
cursor.each { ... }
array.each { ... }
feed.each { ... }
Ленивая итерация по набору результатов по одному элементу за раз.
Пример: Обработка всех элементов!
cursor = r.table('users').run(conn)
cursor.each { |doc|
process_row(doc)
}
to_a
cursor.to_a()
Получение всех результатов в виде массива.
Пример: Для небольших наборов результатов может быть удобнее обработать их сразу как массив.
cursor = r.table('users').run()
users = cursor.to_a()
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 => nil
}
],
: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 => nil
}
],
: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 => nil
}
],
: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 => nil
}
],
: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
table.set_write_hook(function | binary | null) → object
Устанавливает обработчик записи в таблице или перезаписывает его, если он уже существует.
Обработчик function может быть анонимной функцией со структурой (context: object, old_val: object, new_val: object) -> object или двоичным представлением, полученным из поля function из get_write_hook. Функция должна быть детерминированной и не может использовать подзапрос или команду r.js.
get_write_hook
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([key, 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')) {|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')) {|marvel_row, dc_row|
marvel_row[:strength] < dc_row[:strength]
}.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{ |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 { |hero|
hero[:defeated_monsters]
}.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(:success_metric).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)
Или, используя оператор диапазона Ruby:
r.table('players').filter({'class': 'amateur'})[10..19].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 => true]) → grouped_stream r.group(sequence, field | function..., [:index => <indexname>, :multi => true]) → 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{|doc| 1 }
.reduce{ |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.eq(''), '', ', ') + 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
Суммирует все элементы последовательности. Если вызывается с именем поля, суммирует все значения этого поля в последовательности, пропуская элементы последовательности, которым это поле отсутствует. Если вызывается с функцией, вызывает эту функцию для каждого элемента последовательности и суммирует результаты, пропуская элементы последовательности, где эта функция возвращает nil или ошибку не-существования.
Пример: Какова сумма 3 + 5 + 7?
r([3, 5, 7]).sum().run(conn)
avg
sequence.avg([field | function]) → number r.avg(sequence, [field | function]) → number
Вычисляет среднее значение всех элементов последовательности. Если вызывается с именем поля, вычисляет среднее значение всех значений этого поля в последовательности, пропуская элементы последовательности, которым это поле отсутствует. Если вызывается с функцией, вызывает эту функцию для каждого элемента последовательности и вычисляет среднее значение результатов, пропуская элементы последовательности, где эта функция возвращает nil или ошибку не-существования.
Пример: Каково среднее значение 3, 5 и 7?
r([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([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([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{|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)
Обработка документов
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('new_boots').run(conn)
prepend
array.prepend(value) → array
Добавляет значение в начало массива.
Пример: Получите список снаряжения Железного человека с добавлением новых ботинок.
r.table('marvel').get('IronMan')[:equipment].prepend('new_boots').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('new_boots').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')[:first_appearance].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('first_appearance').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) → nil/object
Сопоставляет строку с регулярным выражением. Если совпадение найдено, возвращает объект с полями:
-
str: Совпавшая строка -
start: Начало совпавшей строки -
end: Конец совпавшей строки -
groups: Группы захвата, определённые скобками
Если совпадение не найдено, возвращает nil.
Пример: Получить всех пользователей, чьё имя начинается с «A». Поскольку nil вычисляется в false в filter, можно просто использовать результат match в качестве предиката.
r.table('users').filter{ |doc|
doc['name'].match("^A")
}.run(conn)
split
string.split([separator, [max_splits]]) → array
Разбивает строку на подстроки. Разбивает по пробелам, если не указан параметр. При указании разделителя, разбивает по этому разделителю. При указании разделителя и максимального числа разбиений, разбивает по разделителю не более max_splits раз. (Можно использовать nil в качестве разделителя, чтобы разбивать по пробелам, при этом всё ещё задавая 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 либо
> a = true > b = false > (r.expr(a) | b).run(conn) true.
> a = true
> b = false
> (r.expr(a) | b).run(conn)
true
eq
value.eq(value[, value, ...]) → bool
Проверить, равны ли два или более значения.
Пример: Проверить, установлено ли поле role пользователя на
value.ne(value[, value, ...]) → bool.
r.table('users').get(1)['role'].eq('administrator').run(conn)
ne
value.ne(value[, value, ...]) → bool
Проверить, не равны ли два или более значения.
Пример: Проверить, не установлено ли поле role пользователя на
r.table('players').get(1)['score'].gt(10).run(conn)
# alternative syntax
(r.table('players').get(1)['score'] > 10).run(conn)
. r.table('users').get(1)['role'].ne('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
Вычислить логическое отрицание (не) выражения.
Пример: Не истина — ложь.
r(true).not().run(conn)
r.not(true).run(conn)
Эти значения эквивалентны false.
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
Создаёт объект времени для определённого момента.
Пример: Обновление даты рождения пользователя «John» на 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
Создаёт объект времени на основе секунд с эпохи. Первый аргумент — число с плавающей точкой, которое будет округлено до трёх знаков после запятой (точность миллисекунд).
Пример: Обновление даты рождения пользователя «John» на 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{ |user|
user["subscriptionDate"].timezone().eq("07:00")
}
during
time.during(start_time, end_time[, :left_bound => "closed", :right_bound => "open"]) → bool
Возвращает, находится ли время между двумя другими временами.
Пример: Получение всех записей, опубликованных между 1 декабря 2013 года (включительно) и 10 декабря 2013 года (исключая).
r.table("posts").filter{ |post|
post['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{ |user|
user["birthdate"].date() == r.now().date()
}.run(conn)
time_of_day
time.time_of_day() → number
Возвращает количество секунд, прошедших с начала дня, сохранённого в объекте времени.
Пример: Получение записей, отправленных до полудня.
r.table("posts").filter{ |post|
post["date"].time_of_day() <= 12*60*60
}.run(conn)
year
time.year() → number
Возвращает год объекта времени.
Пример: Получение всех пользователей, родившихся в 1986 году.
r.table("users").filter{ |user|
user["birthdate"].year().eq(1986)
}.run(conn)
month
time.month() → number
Возвращает месяц объекта времени как число от 1 до 12. Для удобства определены термины r.january, r.february и т. д., сопоставленные с соответствующим целым числом.
Пример: Получение всех пользователей, родившихся в ноябре.
r.table("users").filter{ |user|
user["birthdate"].month().eq(11)
}
day
time.day() → number
Возвращает день объекта времени как число от 1 до 31.
Пример: Возвращение пользователей, родившихся 24 числа любого месяца.
r.table("users").filter{ |user|
user["birthdate"].day().eq(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{ |user|
user["birthdate"].day_of_year().eq(1)
}
hours
time.hours() → number
Возвращает час в объекте времени как число от 0 до 23.
Пример: Возвращение всех записей, отправленных после полуночи и до 4 часов утра.
r.table("posts").filter{ |post|
post["date"].hours() < 4
}
minutes
time.minutes() → number
Возвращает минуту в объекте времени как число от 0 до 59.
Пример: Возвращение всех записей, отправленных в первые 10 минут каждого часа.
r.table("posts").filter{ |post|
post["date"].minutes() < 10
}
seconds
time.seconds() → number
Возвращает секунды в объекте времени как число от 0 до 59.999 (с двойной точностью).
Пример: Возвращение записей, отправленных в первые 30 секунд каждой минуты.
r.table("posts").filter{ |post|
post["date"].seconds() < 30
}
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 Epoch с точностью до миллисекунды.
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 = File.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('f19b5f16-ef14-468f-bd48-e194761df255').do { |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 или nil (т.е., «истинностных» значений), с финальной командой «иначе», которая выполняется, если все условные выражения являются false или nil.
Пример: Проверить значение 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 {|hero|
r.table('villains').get(hero[:villain_defeated]).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 { |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 оценивает свой первый аргумент (значение, к которому она прикреплена). Если этот аргумент возвращает nil или возникает ошибка несоответствия при оценке, тогда default возвращает свой второй аргумент. Второй аргумент обычно представляет собой значение по умолчанию, но это может быть функция, возвращающая значение.
Пример: Получить названия и авторов таблицы posts. В случае отсутствия поля автора или nil, мы хотим получить строку Anonymous.
r.table("posts").map{ |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.
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 { |post|
{ :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
value.to_json_string() → string
Преобразовать значение или объект ReQL в строку JSON.
Пример: Получить документ ReQL в виде строки JSON.
> r.table('hero').get(1).to_json_string()
'{"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(:non_atomic => true){ |doc|
{ :rectangle => doc['rectangle'].fill() }
}.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 => { nil }
}
]
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 => nil]}) → object
database.reconfigure({:shards => <s>, :replicas => <r>[, :primary_replica_tag => <t>, :dry_run => false, :nonvoting_replica_tags => nil]}) → 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_status('superheroes').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
Ожидать готовности таблицы (или таблиц). Таблица может быть временно недоступна после создания, перебалансировки или переконфигурации.
Пример: Ожидать готовности таблицы.
> 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/ruby/
