
Spanish: 
Hola a todos.
Soy Florina Muntenescu,
Developers Advocate.
Yo soy Daniel Santiago y trabajo
en el Toolkit de Android.
Room se creó para simplificar
el trabajo con bases de datos en Android
agregando consultas basadas
en tiempo de compilación
y facilitando la implementación
de migraciones y las pruebas.
Desde la versión 1.0,
Room fue obteniendo más funciones.
En Room 1.1, ampliamos
la compatibilidad con RxJava
y agregamos las consultas sin formato.
Room 2.0 fue la migración a AndroidX.
Luego, en Room 2.1,
agregamos varias funciones avanzadas,
como búsqueda de texto completo y vistas.
Después, ustedes pidieron más mejoras.

Indonesian: 
-Halo semua.
Saya Florina Muntenescu,
developer advocate.
-Saya Daniel
Santiago, saya bekerja di Android Toolkit.
-Room dibuat
untuk menyederhanakan
proses kerja dengan database di Android
dengan menambahkan kueri terperiksa
waktu kompilasi dan cara yang lebih mudah
untuk menerapkan
migrasi dan melakukan pengujian.
Namun sejak versi 1.0, Room
manambahkan lebih banyak fitur.
Di Room 1.1, kami
memperluas dukungan RxJava
dan kami
menambahkan kueri mentah.
Room 2.0 hanya
merupakan migrasi ke AndroidX.
Namun untuk Room 2.1, kami
menambahkan beberapa fitur lanjutan,
seperti tampilan
dan penelusuran teks lengkap.
Namun, kami menerima masukan
bahwa versi ini masih bisa disempurnakan.

English: 
[MUSIC PLAYING]
FLORINA MUNTENESCU:
Hello, everyone.
I'm Florina Muntenescu, and
I'm a developer advocate.
DANIEL SANTIAGO RIVERA:
I'm Daniel Santiago Rivera,
and I work on the
Android Toolkit.
FLORINA MUNTENESCU:
Room was created
to simplify working with
databases in Android
by adding compile-time checked
queries and an easier way
to implement migrations
and an easier way to test.
But since 1.0, Room added
more and more features.
In Room 1.1, we extended
the RxJava support
and we've added the raw queries.
Room 2.0 just meant a
migration to AndroidX.
But then with Room 2.1,
we've added several advanced
features, like full-text
search and views.
But then you told us that
there is room for improvement.

Portuguese: 
[MÚSICA TOCANDO]
Olá, pessoal.
Sou Florina Muntenescu,
mediadora de desenvolvedores.
Sou Daniel Santiago Rivera
e trabalho no Android Tooklit.
A Room foi criada para
simplificar o trabalho com
bancos de dados no Android,
incluindo consultas com verificação de tempo
de compilação e facilitando
a implementação de migrações e
realização de testes.
Desde a Room 1.0, muitos outros
recursos foram adicionados.
Na Room 1.1, estendemos o suporte a RxJava
e adicionamos as consultas brutas.
A Room 2.0 significou uma
migração para o AndroidX.
Depois, com a Room 2.1,
incluímos vários recursos avançados,
como pesquisa de texto completo
e visualizações.
Depois, vocês nos disseram que
havia espaço para melhorias.

Chinese: 
大家好 我是开发推广工程师 Florina Muntenescu 
我是 Daniel Santiago Rivera
效力于 Android Toolkit 团队
我们创建 Room 的目的是让用户可以更轻松地
在 Android 中操作数据库
具体做法是添加编译时查询检查
简化迁移和测试的流程
自1.0版本以来 Room 添加了很多功能
在 Room 1.1 中 我们增加了对 RxJava 的支持
还加入了原始查询
Room 2.0 意味着我们迁移到了 AndroidX
随着 Room 2.1 的到来 我们添加了几个高级功能
例如全文搜索和视图
随后 你们告诉我们 还有可以改进的空间
随后在 Room 2.2 中 

Japanese: 
こんにちは
みなさん
デベロッパーアドボケイトの
Florinaです
Danielです
Androidツールキットチーム所属です
Roomが開発されたのは
Androidのデータベース操作の
簡略化に向け
コンパイル時にチェックされる
クエリや
移行のテストと実施を容易にする
方法を追加するためでしたが
1.0以降 Roomには
多くの機能が追加されました
Room 1.1では
RxJavaのサポートを拡張し
生のクエリを追加しました
Room 2.0はAndroidXへの
移行が目的でした
Room 2.1では
全文検索やビューなど
高度な機能を追加しました
しかし まだ改善の余地があるという
意見を皆さんから頂きました

Korean: 
[음악 재생]
안녕하세요 여러분
저는 Developer Advocate인
플로리나 먼테네스쿠입니다
저는 다니엘 산티에고 리베라이고
Android 툴킷을 담당하고 있습니다
Room은
Android에서 데이터베이스 작업을
간소화하기 위해 만들어졌어요
컴파일-시간 확인 쿼리와 더욱 손쉽게
이전하고 테스트할 수 있는 방식을
제공하기 때문이죠
하지만 1.0 버전 이후로
더욱 많은 기능이 더해졌어요
Room 1.1에서는 RxJava 지원을 확대하고
원시 쿼리를 추가했습니다
Room 2.0은 단순히 AndroidX로
이전한 버전이고
Room 2.1에서는 여러 고급 기능을 추가했어요
전체 텍스트 검색 및 보기와 같은 기능을요
하지만 여러분이 개선사항을 제안해주셨어요

Japanese: 
そこで Room 2.2では
要望があった機能を
いくつか実装しました
本日はRoom 2.2で実装した
機能についてお話しします
ありがとう
Roomはリリースされた当初から
DAOとクエリを定義して
データを取得する機能を
提供してきました
これはブロッキング処理により
同期的に実行できます
一方でRoomはLiveDataも
扱うことができ
オブザーバブルなデータセットの結果
を取得できます
データベースが変更されると
新しい結果セットが得られるのです
しかし 単発操作のような
機能はなく
ユーザーに任せていました
開発を進める中で
Rxのサポートを追加しました
これは補完が目的で
オブザーバブルなクエリと
単発操作の両方のタイプを
使えるようになりました
RoomはLifecycleより前に生まれた
Guavaもサポートしています
オブザーバブルなクエリはなく
単発操作のみです

Chinese: 
我们采纳了大家的一些意见
所以 今天我们要来谈谈 我们在 Room 2.2 中都做了什么
谢谢
一直以来 Room 都致力于让你有能力定义 Dao 和查询
并获取返回的数据
你可以通过阻断的方法同步式地做到这一点
Room 也可以和 LiveData 协同
你可以获取可观测的数据集
如果它背后的东西改变了
你就会获得一套新的结果
但是它没有为一次性操作做好准备
这个主要靠各位来完成
随着开发进度的推进
我们添加了对 Rx 的支持
这就是一套完整的故事了
可观测查询和一次性操作都有自己的类型
Room 还支持 Guava 
这个相较于 Lifecycle 有点落后了
没有可观测性 但仍然支持一次性操作

Portuguese: 
Então, na Room 2.2, ouvimos sobre alguns
dos recursos que vocês pediram
e os implementamos.
Hoje, vamos falar sobre
o que fizemos na Room 2.0.
Obrigado.
Desde o começo, a Room sempre ofereceu
recursos para definir um DAO
e uma consulta
e ter alguns dados de volta.
Vocês puderam fazer isso
de forma síncrona e de bloqueio.
A Room também é definida
com dados semelhantes.
Podemos ver resultados
de conjuntos de dados observáveis.
Se algo mudar neles,
teremos um novo conjunto
de resultados.
Mas não havia nada para
operações individuais.
De um modo geral, isso era com vocês.
À medida que desenvolvimento avançou,
incluímos compatibilidade com Rx
e foi uma história completa.
Vocês têm consultas observáveis
e operações individuais.
A Room também é compatível com Guava,
e algumas versões anteriores do Lifecycle.
Sem observabilidade, mas com
operações individuais.

Spanish: 
Entonces, para Room 2.2, consideramos
algunas de las funciones que pidieron
y las implementamos.
Hoy, hablaremos del trabajo
que hicimos en Room 2.2.
Gracias.
Desde el principio, Room les dio opciones
para definir un dao y una consulta
y, luego, obtener datos como resultado.
Y podían hacerlo de manera síncrona
con un método de bloqueo.
Pero Room también
daba formato con datos similares
y contaba con un método para obtener
conjuntos de datos observables.
Por ello, si algo cambiaba
a nivel interno,
obtendrían un nuevo conjunto
de resultados.
Pero no tenía nada
para funciones de un solo uso.
Eso dependía casi totalmente de ustedes.
Durante el proceso de desarrollo,
agregamos compatibilidad con Rx
para completarlo.
Tienen tipos para consultas observables
y operaciones de un solo uso.
Room también admite Guava,
lo que comenzó antes de Lifecycle.
No había observabilidad,
pero sí operaciones de un solo uso.

Korean: 
그래서 Room 2.2에서는 여러분 의견을 듣고
요청하신 일부 기능을
구현했습니다
오늘은 Room 2.2의 개선 사항을
알아보겠습니다
감사합니다
처음부터 Room은 항상
DAO와 쿼리를 정의하고 데이터를 돌려받는
기능을 제공해왔습니다
이러한 작업을 동시에
수행할 수 있었죠
블로킹 방식으로 말이에요
하지만 Room은 데이터와 같은
형태로 이루어져 있어
관찰 가능한 데이터 세트
결과를 얻을 수 있었죠
Room 안에서 어떤 요소가 변경되면
새로운 결과를 얻게 되죠
하지만 일회성 연산과 같은 기능은 없었고
거의 전적으로 사용자에 달려있었죠
개발이 진행되면서 Rx 지원을 추가했어요
이게 전부입니다
관찰 가능한 쿼리와 일회성 연산의
여러 유형이 제공됩니다
Room은 Guava도 지원하는데
Lifecycle에서 약간 반대 방향으로
가는 거죠
관찰 가능성은 없지만
일회성 연산 기능이 있었어요

Indonesian: 
Jadi, di Room 2.2,
kami telah mempertimbangkan
beberapa fitur yang Anda minta
dan menerapkannya.
Hari ini kami akan
membahas apa saja
yang telah kami
lakukan di Room 2.2.
-Terima kasih.
Sejak awal, Room selalu
memberikan kemampuan
untuk menentukan DAO dan kueri
lalu mengembalikan beberapa data.
Anda dapat
melakukannya secara sinkron
dengan cara yang menghambat.
Namun, Room juga
dibentuk dengan LiveData,
dan ada cara untuk mendapatkan
hasil set data yang dapat diamati.
Jika ada perubahan di bawahnya,
Anda akan mendapatkan
kumpulan hasil yang baru.
Namun versi itu tidak sesuai
untuk, misalnya operasi satu kali.
Ini sebagian besar
bergantung pada Anda.
Seiring dengan pengembangan,
kami menambahkan dukungan untuk Rx,
lalu semuanya jadi lengkap.
Tersedia jenis untuk
kueri yang dapat diamati
dan operasi satu kali.
Room juga mendukung
Guava yang merupakan sedikit kemunduran
dari Lifecycle.
Tidak ada kemampuan dapat diamati
tapi ada operasi satu kali.

English: 
So then, in Room 2.2,
we've been listening
to some of the features
that you've asked
and we've implemented that.
So today, we're going
to talk about what
we've done in Room 2.0.
DANIEL SANTIAGO RIVERA: Thanks.
So since the beginning,
Room has always
given you the capabilities
to define a dao and a query
and then get some data back.
And you've been able to
do this synchronously
in a blocking way.
But Room also shaped
with like data,
and there was a way to get
observable data set results.
So if something
changed underneath it,
you would get a
new set of results.
But it didn't have anything
for, like, one-shot operations.
That was mostly up to you.
As development progressed,
we added support for Rx,
and this was a complete story.
You have types for
both observable queries
and one-shot operations.
Room also supports Guava and
this was a little backwards
from Lifecycle.
No observability but there
was one-shot operations.

Chinese: 
在 Room 2.1 中 我们开始采用协程
并添加了 suspend 方法
这些都属于“一次性操作”的范畴
不过 在 Room 2.0 中
我们添加了可观测的 Flow
这就填补了协程的空白
现在你的协程应用就完整了
那么 Flow 是什么呢？
我们来快速了解一下
Flow 可以说是比较新的一款 Kotlin 协程原语
它的好处在于 它是 lazy 的
你发出数据之后 接收端就会等待接收更多数据
API 本身分为两种操作
一种是在中间操作数据流的 比如 map 和 filter
另一种则是在最后汇总数据的 
下面我们来看代码和示例吧
比如 我们在制作一款特别擅长寻找狗狗的应用

Japanese: 
Room 2.1では
コルーチンを導入し
suspend関数を追加しました
これは単発操作カテゴリに
該当します
Room 2.2では
オブザーバブルなFlowを追加しました
これによりコルーチンが補完され
完全なコルーチンアプリを
構築可能になりました
ではFlowとは何でしょうか
その概要を説明します
Flowは比較的新しい
Kotlinコルーチンの
プリミティブです
Flowの長所は遅延的である点です
データを発信した後
さらにデータを発信するには
受信側がそれを
許可する必要があります
このAPIの処理は２種類あり
mapやfilterなど
さまざまな中間オペレータからの
データを変換する処理と
データを利用する処理があります
コード例を見てみましょう
最高の子犬検索アプリを
作ろうとしていて

Portuguese: 
Na Room 2.1, começamos com
as Corrotinas e adicionamos
uma função suspensa.
Isso se enquadra nessa categoria
de operações individuais.
Na Room 2.2, adicionamos fluxo observável,
o que complete a questão das Corrotinas
para que vocês tenham um app
de Corrotinas completo.
Mas o que é o Flow?
Vamos resumir o que é o Flow.
É basicamente, um primitivo novo
das Corrotinas da Kotlin
O legal aqui é que isso é [INAUDÍVEL].
Você emite alguns dados e precisa
de alguém do lado receptor
para que mais dados sejam admitidos.
A API é dividida em dois tipos
de operação:
aquelas que formam os dados
a partir de diferentes
operadores intermediários,
como mapas e filtros,
e aquelas que os consomem.
Vamos ver alguns códigos e exemplos.
Imagine que estejamos criando
o melhor app para encontrar filhotes

Korean: 
Room 2.1에서는 코루틴을 사용하기 시작했고
정지 함수를 추가했습니다
이들은 일회성 연산 카테고리에
속하죠
하지만 Room 2.2에서
관찰 가능한 Flow를 추가했고
이를 통해 코루틴이 완성되어
완전한 코루틴 애플리케이션이 제공됩니다
그런데 Flow란 무엇일까요?
Flow가 뭔지 살펴보죠
Flow는 기본적으로 비교적 새로운 Kotlin 코루틴의
초기 단계와도 같습니다
장점은
데이터를 보내면
수신측에 누군가 있어야
더 많은 데이터를 받아들일 수 있다는 점입니다.
API 자체가 두 연산으로 분리되어
하나는 맵, 필터 등 다양한 중간 연산자로부터
데이터를 구성하고
다른 하나는 이러한 데이터를 소비합니다
코드와 예시를 보여드리죠
최고의 강아지 찾기 애플리케이션을
만든다고 가정하고

English: 
In Room 2.1, we started
going the Coroutines route
and we added a suspend function.
And these fall
into that category
of one-shot operations.
But in Room 2.2, we
added observable flow,
and this completes
that Coroutine story
so you can have a full
Coroutine application.
But what is Flow?
Let's look at a rundown
on what Flow is.
Flow is basically like a
relatively new Kotlin Coroutine
primitive.
The cool thing about it
is that it's [INAUDIBLE]..
So you emit some
data and there has
to be someone on
the receiving side
for more data to be admitted.
The API itself is split into
two kinds of operations--
there's those that form
the data from varying
intermediate operators,
like map and filter,
and there's those
that consume it.
But let's see some
code and some examples.
So imagine we're making the
best puppy-finding application

Spanish: 
En Room 2.1, agregamos Corrutinas
y una función de suspensión.
Ambas forman parte de la categoría
de operaciones de un solo uso.
En Room 2.2, agregamos
compatibilidad con Flow,
lo que completa el proceso de Corrutinas,
para que puedan tener una aplicación
completamente basada en Corrutinas.
¿Pero qué es Flow?
Veremos de qué se trata.
Flow es básicamente una Corrutina
de Kotlin bastante nueva, primitiva.
Una ventaja es que ustedes emiten datos
y debe haber alguien para recibirlos
para que puedan emitirse más datos.
La API se divide
en dos tipos de operaciones:
las que forman los datos
a partir de operadores intermediarios,
como mapas y filtros,
y las que los consumen.
Veamos algo de código y ejemplos.
Imaginemos que haremos
una app para encontrar cachorros

Indonesian: 
Di Room 2.1, kami mulai
menggunakan rute Coroutines
dan menambahkan fungsi penangguhan.
Ini termasuk dalam kategori
operasi satu kali.
Namun di Room 2.0, kami
menambahkan alur yang dapat diamati,
dan ini
melengkapi alur Coroutine
sehingga Anda dapat menggunakan
aplikasi Coroutine yang lengkap.
Lalu apa itu Flow?
Mari kita bahas
Flow secara singkat.
Flow dapat disebut
sebagai primitif Kotlin Coroutine
yang baru.
Menariknya, Flow bersifat [...]
Jadi Anda
mengirimkan data dan harus
ada seseorang di sisi penerima
agar dapat menerima lebih banyak data.
API-nya dibagi
menjadi dua jenis operasi,
ada yang membentuk data dari berbagai
operator menengah,
seperti map dan filter,
dan ada yang menggunakannya.
Mari lihat beberapa kode dan contoh.
Bayangkan kita membuat
aplikasi pencari anak anjing terbaik

Portuguese: 
e precisamos fornecer uma API
para localizar alguns cães
e levá-los para casa.
Isso tem que ser assíncrono, 
porque, às vezes,
localizar cães é difícil
e pode levar tempo.
Temos também um parâmetro aqui que limita
o total de cães localizados.
Se tivéssemos que criar isso,
começaríamos com o Flow Builder.
O Flow Builder usa um lambda.
No corpo desse lambda, você cria a lógica
que poderá fornecê-lo.
Nesse caso, localizar e 
emitir os cães.
O tipo de receptor é um
coletor do Flow.
Ele tem uma única função: emissão.
O interessante aqui é que a emissão
é uma função suspensa.
Isso porque alguém no lado receptor
precisa estar coletando os dados
antes de a função ser concluída
e de seu corpo continuar.
Se fôssemos chamar a função,
usaríamos operadores de terminal,
como os de coleta.
Se executarmos isso, receberemos
vários filhotes

Indonesian: 
dan kita perlu menyediakan
API untuk menemukan anjing
dan memeliharanya.
Ini akan menjadi
asinkron karena terkadang
menemukan anjing itu sulit
dan mungkin memerlukan waktu yang lama.
Kami juga memiliki
parameter yang membatasi
jumlah anjing yang ditemukan.
Seandainya kita
membuat ini, kita akan
mulai dengan Flow Builder.
Dan Flow Builder
memerlukan lambda.
Di isi lambda,
Anda harus menulis logika
agar dapat memberikannya.
Dalam kasus ini, untuk
menemukan anjing dan mengirimkan datanya.
Jenis penerima adalah Flow Collector.
Fitur ini hanya
memiliki fungsi emit.
Bagian menariknya yakni emit
adalah fungsi menangguhkan.
Dan ini karena seseorang di sisi penerima
harus mengumpulkan
data sebelum fungsi ini selesai
dan isi kode Anda berlanjut.
Jika kita memanggil fungsi ini,
kita akan menggunakan salah
satu operator terminal seperti collect.
Jika dijalankan, kita akan
mendapatkan banyak anak anjing
dan memeliharanya,
dan ini sangat hebat.

English: 
and we need to provide an
API for finding some dogs
and pet them.
This has to be asynchronous
because sometimes
finding dogs is tricky
and might take some time.
We also have a parameter
here that limits
the amount of dogs we get.
If we were to build
this, we would
start with a Flow Builder.
And the Flow Builder
takes a lambda.
In the body of this
lambda, you write the logic
to be able to provide that.
In this case, to get
our dogs and emit them.
The receiver type
is a Flow collector.
It only has one function, emit.
So the interesting
part here is that emit
is a suspend function.
And it is because that means
somebody on the receiving end
must be collecting the data
before this function completes
and your body continues.
If we were to call
the function, we
use one of those terminal
operators like collect.
If we execute this, we'll be
getting a bunch of puppies

Japanese: 
ペットにする犬を
検索するためのAPIを
提供する必要があるとします
犬の検索は複雑で
時間がかかるため
非同期で処理する必要があります
ここでは
取得する犬の数を制限する
パラメータを指定しています
これを作成するには
まずFlow Builderで
ラムダを受け取ります
このラムダの本文に
犬を取得して出力する
ロジックを記述します
レシーバ型はFlowCollectorです
関数はemitのみです
面白いことに このemitは
suspend関数です
そう呼ばれているのはなぜかと言うと
この関数を終了して
次の処理に進む前に
受信側がデータを
収集しなければならないからです
この関数を呼び出す場合
collectなどの
終端オペレータを使用します
これを実行すると
多数の子犬を取得して

Spanish: 
y necesitamos una API
para encontrar perros y acariciarlos.
El proceso tiene que ser asíncrono
porque, a veces, encontrar perros
es difícil y puede llevar mucho tiempo.
También tenemos un parámetro aquí
que limita la cantidad de perros
que podemos obtener.
Para compilar esto,
debemos empezar con Flow Builder.
El Flow Builder lleva una lambda.
En el cuerpo de la lambda,
escriben la lógica
para proporcionar la función.
En este caso, obtener perros y emitirlos.
El tipo de receptor
es un recopilador de Flow.
Solo tiene una función: emitir.
Lo interesante es que emitir
es una función de suspensión.
Esto se debe a que el receptor
debe recopilar los datos
para que la función se complete
y el proceso pueda continuar.
Para llamar a esta función, usamos
un operador terminal, como "collect".
Al ejecutarlo, obtendremos
un grupo de cachorros
y ya los habremos acariciado,
lo que es increíble.

Chinese: 
而且我们需要提供 API 用来寻找并抚摸它们
这个操作必须是异步进行的
因为有时候 找到一条狗是很麻烦的 需要一定的时间
我们在这里还有一个边界条件 用来限制我们获得的狗的数量
我们的构建工作始于 Flow Builder
Flow Builder 接收一个 lambda
在这个 lambda 的本体中
你可以写下逻辑来提供相关信息
在本例中 也就是找到狗狗数据并发送
接收器类型是 Flow 收集器
它的功能只有一个：发送
有意思的地方在于 这是个 suspend 方法
这是因为 这意味着接收者
肯定在这个功能完成和主体继续工作之前就在收集数据了
假如要调用这个函数 我们就要使用
终端执行器 如 collect
如果我们执行它 
就会得到一大堆狗狗 并逐个抚摸 就很棒

Korean: 
강아지를 찾고 기르려면
API를 제공해야 해요
이 작업은 비동기식으로 이루어져야 해요
강아지를 찾는 것은 쉽지 않고
어느 정도 시간이 걸릴 수 있기 때문이죠
여기에는 매개변수도 있어요
찾는 강아지의 마리 수를 제한하는 거죠
이를 빌드하려면
Flow Builder로 시작하는데
Flow Builder에는 람다가 필요합니다
람다 본문에 해당하는 로직을
작성합니다
이 경우에는 강아지를 찾아 방출하는 거겠죠
수신기 유형은 Flow Collector이고
유일한 함수는 emit입니다
여기서 흥미로운 점은 emit이
정지 함수라는 점이에요
즉 수신측의 누군가는
데이터를 수집하고 있어야 합니다
이 함수가 완성되고
본문이 진행되기 전에 수집해야 하죠
이 함수를 호출하려면
collect와 같은 터미널 연산자 중 하나를 사용합니다
그리고 이를 실행하면 많은 강아지를 찾고

English: 
and petting them,
which is amazing.
On the other end, if we
use a limit of three,
we would only get three dogs.
And three dogs is still
pretty cool, in my opinion.
In terms of room, in your
dao, you can now basically
have a query function
that returns a Flow,
and it'll behave like
expected in the sense
that you will get a
list of your result.
But then it's observable.
And if we initialize it,
imagine we have a Room database.
On the other end, we're
trying to display our puppies.
When we get it, we
get a list of puppies.
But then if something
changes on the database,
like we download
dogs from the cloud,
you're going to need emission.
And this emission contains
both the old result set
and the new one.
The cool thing about Flow--
and supporting Flow
in Coroutines--
is that you can
start combining it
with the rest of the
effort we've been doing
with regards to Coroutine.

Indonesian: 
Di sisi lain, jika
menggunakan batas dengan nilai tiga,
kita akan mendapatkan tiga anjing.
Dan tiga anjing sudah
cukup bagus menurut saya.
Sehubungan dengan
Room, dalam DAO, kini Anda dapat
membuat fungsi
kueri yang menampilkan Flow,
dan fungsi ini akan
berperilaku sesuai harapan, dalam artian
Anda akan mendapatkan daftar hasil.
Ini tetap dapat diamati.
Dan jika kita memulainya,
bayangkan akan tersedia database Room.
Di sisi lain, kita berupaya
untuk menampilkan anak anjing.
Saat mendapatkannya, kita
akan punya daftar anak anjing.
Namun jika ada
perubahan pada database,
misalnya kita
mendownload anjing dari cloud,
Anda akan memerlukan pengiriman.
Pengiriman ini berisi
kumpulan hasil sebelumnya
dan yang baru.
Hal menarik tentang Flow,
dan mendukung Flow di Coroutines,
adalah Anda bisa
mulai mengombinasikannya
dengan semua hasil
lainnya yang telah dilakukan
sehubungan dengan Coroutine.

Spanish: 
Por otro lado, si usamos
un límite de tres,
solo obtendremos tres perros.
Y tres perros sigue siendo
una buena cifra, creo yo.
En términos de espacio, en su dao,
pueden tener una función de consulta
que muestre un Flow
y esta se comportará de manera esperada,
ya que obtendrán la lista de resultados.
Estos son observables.
Al inicializarla, imaginemos que tenemos
una base de datos de Room.
En el otro extremo,
intentaremos mostrar los cachorros.
Cuando la obtengamos,
veremos la lista de cachorros.
Pero si algo cambia en la base de datos,
por ejemplo, descargamos
perros de la nube,
necesitaremos una emisión.
Esta emisión contiene
tanto el conjunto de resultados antiguos
como el nuevo.
Lo interesante de Flow,
y de admitir Flow en Corrutinas,
es que pueden combinarlo
con el resto de las acciones
que hicimos relacionadas con Corrutinas.

Chinese: 
然而 如果我们把数量限制在3个
那么就只能获得3条狗
不过在我看来 3条狗也很好了
再来谈谈 Room
在你的 Dao 中 现在你可以
让查询函数返回 Flow
它会发挥期望中的作用 
也就是类似结果列表那样
但它是可观测的
如果我们初始化它
想象一下 我们有一个 Room 数据库
同时 我们正在试着展示我们的狗狗
成功之后 我们就会获取一个狗狗列表
如果数据库发生变动
比如我们从云端下载狗狗
这时你就需要发送数据
这个发送的数据含有新旧两个版本的结果集
Flow 以及用协程支持 Flow 的一个优点是
你可以把它和我们一直以来在协程方面的工作结合起来

Japanese: 
ペットにできます
すばらしいですね
３を制限に使用した場合は
犬を３匹しか
取得できませんが
３匹でも十分だと思います
Roomを使用する場合
DAOで
Flowを返すクエリ関数を使用できます
これはご想像のとおり
結果のリストを取得する
処理を実行します
またこれはオブザーバブルです
これを初期化し
Roomデータベースを用意して
画面で子犬を表示するとしましょう
データを取得すると
子犬のリストが表示されますが
クラウドからのダウンロード
などにより
データベースが変更されると
出力が必要になります
この出力には新しい結果セットと
古い結果セットの両方が含まれます
Flowや
コルーチンでのFlowサポートの
優れた点は
Flowをコルーチンに関係する
他のものと組み合わせることが
できる点です

Korean: 
기를 수 있는 거죠
반면에 강아지를 3마리로 제한하면
강아지를 3마리밖에 찾지 못하죠
개인적으로 3마리도 좋다고 생각해요
Room의 경우 이제 DAO에
Flow를 반환하는 쿼리 함수를 포함할 수 있고
예상대로 동작할 거예요
결과 목록을 받게 되니까요
또한 관찰 가능합니다
초기화할 때
Room 데이터베이스가 있다고 가정해보죠
또한 강아지를 화면에 표시하려고 합니다
그렇게 되면 강아지 목록을 받게 됩니다
데이터베이스에 변경사항이 있는 경우
예를 들면 클라우드에서
강아지를 다운로드하는 등 말이죠
그렇다면 방출이 필요하게 됩니다
이러한 방출에는 이전 결과 세트와 새로운 결과 세트가
둘 다 포함됩니다
Flow와
코루틴에서의 Flow 지원의 장점은
Flow를
코루틴과 관련된 다른 작업에
결합할 수 있다는 점입니다

Portuguese: 
e cuidaríamos deles, o que seria incrível.
Por outro lado, se usarmos
um limite de três itens,
receberíamos apenas três cães.
Três cães ainda é muito bom,
na minha opinião.
Em relação à Room, no seu DAO,
agora é possível
ter uma função de consulta
que retorne um fluxo,
que vai se comportar como
o esperado, porque
você terá uma lista do resultado.
Depois, pode ser observado.
Se nós o inicializarmos,
poderemos ter um banco de dados Room.
Por outro lado, tentaremos
mostrar nossos filhotes.
No final, teremos uma lista de filhotes.
Se algo mudar no banco de dados,
por exemplo, o download
dos cães na nuvem,
precisaremos da emissão.
E nela contém o conjunto de
resultados antigo e novo.
O legal sobre o Flow e a
compatibilidade do Flow com Corrotinas
é que você pode começar a combiná-los
com o restante dos esforços
que estamos fazendo
em relação às Corrotinas.

Chinese: 
尤其值得一提的是 你可以把它和 Lifecycle 扩展结合起来
这样你就能启动协程
在 Fragment 启动的时候 你就可以开始收集并展示狗狗
这相当不错
大家曾告诉我们 你们需要重新填充数据的能力
这样每当用户安装你们的应用时
你们就能直接展示出 最好的狗狗
因此 你需要使用预先打包好的数据库
这个数据库要么是你的 APK 的一部分
要么就来自后端
所以 如果你想要自己来实现它的话
就需要去做很多工作
包括打开数据库 确认 schema 锁定数据库文件 等等
这会消耗你构建其他功能的精力
在 Room 2.2 中 我们在 DatabaseBuilder 中添加了2个新方法

Korean: 
특히 Lifecycle 확장과 결합하면
코루틴을 시작할 수 있습니다
프래그먼트가 시작되면
강아지를 모아서 표시할 수 있어요
꽤 깔끔하죠
애플리케이션을
재구성할 수 있는 기능을
원한다는 의견이 있었어요
즉, 사용자가 앱을 설치하기만 하면
즉시 최적의 강아지를 보여줄 수 있는 거죠
이렇게 하려면
사전 패키징된 데이터베이스를 사용합니다
이 데이터베이스는 APK의 일부이거나
백엔드에서 가져와야 합니다
따라서 이 작업을 혼자서 구현하려면
많은 작업을 수행해야 해요
데이터베이스를 여는 것부터, 스키마를 인증하고
데이터베이스 파일을 잠그는 등이 있죠
실제로 해야 할 일에서 멀어지게 만들죠
예를 들면 기능을 빌드해야 하는 등 말이에요
그래서 Room 2.2에는 데이터베이스 필터에
새로운 두 가지 메서드인 createFromFile과

Spanish: 
Sobre todo, pueden combinarlo
con extensiones de Lifecycle
que les permitirán iniciar una Corrutina.
Cuando se inicia el fragmento,
pueden empezar
a recopilar perros y mostrarlos,
lo que es muy conveniente.
Bien, ustedes nos indicaron
que quieren tener la opción
de autocompletar su aplicación.
De manera que,
cuando los usuarios la instalen,
ya puedan mostrarles los mejores perros.
Para lograrlo, pueden usar
una base de datos ya preparada.
Esta base de datos sería parte de su APK
o vendría de un backend.
Por lo tanto, si deben
implementarla por su cuenta,
deben realizar varias tareas,
como abrir la base, validar el esquema,
y bloquear el archivo
de la base, entre otras,
lo que los distraerá de lo importante,
que son las funciones que deben crear.
En Room 2.2, agregamos dos métodos nuevos

Japanese: 
特に コルーチンを起動できる
Lifecycle拡張と
組み合わせることが可能です
このフラグメントを開始すると
これらの犬の収集を開始して
表示を開始できますので
とてもすばらしいと思います
ユーザーの方々から
アプリにデータを再入力できるように
したいという要望を頂きました
アプリをインストールすると
最適な犬が表示されるように
するとします
これを行うには
パッケージ済みデータベースを
使います
これはAPKに含めることも
バックエンドから提供することも
できます
自分でこれを実装すると
データベースの起動
スキーマの検証
データベースファイルのロックなど
多くの処理が必要になるため
必要な機能の構築に
時間をかけられなくなります
Room 2.2では
データベースフィルタの２つのメソッド
createFromFileと

Indonesian: 
Khususnya, Anda dapat
menggabungkannya dengan ekstensi Lifecycle
yang akan memungkinkan
Anda meluncurkan Coroutine.
Saat fragmen dimulai, Anda
dapat mulai mengumpulkan
anjing dan menampilkannya.
Ini cukup rapi.
-Anda berkata
bahwa Anda ingin
bisa mengatur ulang aplikasi.
Jadi, kapan pun
pengguna menginstal aplikasi,
Anda ingin sudah bisa
menampilkan anjing terbaik.
Untuk melakukannya, Anda akan
menggunakan
database yang telah dipaketkan.
Database ini akan menjadi bagian APK
atau berasal dari backend.
Jadi, jika harus menerapkannya sendiri,
Anda harus melakukan banyak hal,
dari membuka database, memvalidasi skema,
mengunci file
database, dan banyak hal lain,
yang menjauhkan
Anda dari hal yang
perlu dilakukan yaitu
membuat fitur Anda.
Jadi di Room 2.2, kami telah
menambahkan dua metode baru
pada filter database, yakni createFromFile

English: 
Especially, you can combine it
with the Lifecycle extensions
that will basically allow
you to launch a Coroutine.
When the fragment
is started, you
can start collecting those
dogs and start showing
them, which is pretty neat.
FLORINA MUNTENESCU:
So you've told us
that you want to be able to
repopulate your application.
So whenever your users
install your app,
you want to be able to
already display the best dogs.
So in order to do
that, you would
use a prepackaged database.
This database would
either be part of your APK
or would come from a backend.
So if you would have to
implement this by yourself,
you would have to
do a lot of things,
from opening the database,
validating the schema,
locking the database
file, and a lot of things,
taking away from
what you actually
need to do-- the features
that you need to build.
So in Room 2.2, we've
added two new methods
on the database
filter, createFromFile

Portuguese: 
Especificamente, podemos combiná-los
com as extensões do Lifcycle
que basicamente permitem
iniciar uma Corrotina.
Quando o fragmento é iniciado, você
pode começar a coletar
os cães e mostrá-los
o que é bem simples.
Então, você nos disseram
que querem poder preencher
novamente seus apps.
Sempre que seus usuários instalarem o app,
vocês querem mostrar os melhores cães.
E para fazer isso, vocês
usariam um banco de dados pronto.
Esse banco de dados seria
parte do APK
ou viria de um back-end.
Então, se tivessem que implementá-lo,
teriam que fazer um monte de coisas:
abrir o banco de dados, validar o esquema,
bloquear o arquivo do banco de dados etc.,
desviando-se do que é
realmente necessário:
os recursos que vocês precisam criar.
Na Room 2.2, adicionamos
dois novos métodos
ao filtro do banco de dados:
createFromFile

Japanese: 
createFromAssetを追加しました
createFromFileはパラメータに
ファイルを受け取ります
ここではダウンロードした
ファイルです
ここで重要な点は
ファイルを読み込み
データをコピーできるよう
ファイルにビュー権限を
設定する必要があることです
APKにデータベースを
パッケージ化する場合は
assetsフォルダに配置します
移行を実行をする場合も
あまり違いはありません
通常 Roomは
次の２つを参照します
デバイスにインストールされている
データベースのバージョンと
コード内
つまり@Databaseで
宣言したバージョンです
パッケージ済みデータベースを
使う場合
パッケージ済みデータベースの
バージョンも参照されます
そのため
移行を実行する場合
パッケージ済みデータベースの
バージョンが１で
コード内で宣言したバージョンが
３の場合
Roomでバージョン１から
バージョン３への移行も処理する
必要があります

Portuguese: 
e createFromAsset.
Com createFromFile, teremos como arquivo
como parâmetro.
Será o arquivo baixado que você têm.
Uma coisa importante aqui é
definir a permissão para
visualizações no arquivo
para que a Room possa ler o
arquivo e copiar esses dados.
Depois, se estiver pre-empacotando
o banco de dados
no APK, coloque-o na pasta "Ativos".
Em relação a trabalho com migrações,
as coisas não são muito diferentes.
Em geral, a Room analisa dois coisas:
a versão do banco de dados
instalada no dispositivo
e a versão que você declara no código.
O mesmo acontece na anotação @Database.
Agora, com bancos de dados
pré-empacotados,
vocês têm mais um player.
Têm o banco de dados pré-empacotado.
Quando está falando sobre migrações,
por exemplo, se o banco de dados
pré-empacotado é
da versão 1, e o que você coloca
no código é da versão 3,
a Room precisa gerenciar a
migração da versão 1
para a versão 3.

Indonesian: 
dan createFromAsset.
Untuk createFromFile,
parameternya adalah file.
Ini adalah file yang Anda download.
Satu hal penting yakni
Anda harus memastikan
bahwa Anda menyetel
Izin Tampilan di file tersebut
agar Room dapat
membacanya dan menyalin data tersebut.
Lalu, jika melakukan
pemaketan awal di database,
di APK, pastikan Anda
meletakkannya di folder Aset.
Dalam hal melakukan migrasi,
tidak banyak yang berbeda.
Secara umum, Room
berfokus pada dua hal,
yaitu versi database
yang diinstal di perangkat
dan versi yang Anda
deklarasikan dalam kode.
Artinya dalam
anotasi @Database.
Kini, dengan
database yang telah dipaketkan,
ada satu faktor lain.
Anda memiliki
database yang telah dipaketkan.
Jadi saat membahas migrasi,
misalnya, jika database
yang telah dipaketkan adalah
versi 1 dan yang Anda
gunakan dalam kode adalah versi 3,
Room harus
menangani migrasi dari versi 1
ke versi 3.

Spanish: 
al filtro de base de datos:
createFromFile y createFromAsset.
Con createFromFile, obtenemos
como parámetro un archivo.
Este será el archivo que descargarán.
Es importante que se aseguren
de establecer
permisos de lectura en su archivo
para que Room
pueda leerlo y copiar los datos.
Luego, si usarán una base de datos
ya preparada en su APK,
asegúrense de incluirla
en la carpeta de elementos.
Los procesos no cambian mucho
en el caso de las migraciones.
En general, Room revisa dos aspectos:
La versión de la base de datos
que instalaron en su dispositivo
y la versión que declaran en el código,
en su anotación @Database.
Ahora, con las bases de datos
ya preparadas,
tienen otro factor en juego,
que es esa base de datos ya preparada.
Cuando trabajen en migraciones,
por ejemplo, si la base de datos
ya preparada es la versión 1
y la que incluyen en el código
es la versión 3,
Room también deberá encargarse
de la migración de versión 1 a versión 3.

Chinese: 
分别是 createFromFile 和 createFromAsset
在 createFromFile 中 我们会得到一个作为参数的文件
这个就是你下载到的文件
这里需要注意的是 你需要确保
设定好这个文件上的查看许可权限
Room 可以读取那个文件 并复制数据
如果你在你的 APK 里预打包数据库的话
请务必把它放进 Asset 文件夹
在处理迁移问题时 情况也大体相同
Room 基本上会关注两件事情：
你的设备上安装的数据库版本
以及你在代码中 也就是在 @Database 注解中声明的数据库版本
现在 随着预打包数据库的出现
你需要关注第三件事情：预打包数据库
在处理迁移问题的时候
例如 当预打包数据库为版本1
而你写进代码中的数据库属于版本3的时候
Room 就必须处理从版本1到版本3的数据迁移

English: 
and createFromAsset.
So createFromFile, we will
get as a parameter a file.
This will be the downloaded
file that you have.
So one important thing
here, you should make sure
that you set View
Permissions on your file
so Room is able to read that
file and copy that data.
And then, if you are
pre-packaging your database
in your APK, make sure you
put it in the Assets folder.
In terms of working
with migrations,
things are not very different.
So in general, Room
looks at two things.
It looks at the database
version installed on your device
and at the version that
you declare in code.
So in your @Database annotation.
But now, with
pre-packaged databases,
you have one more player.
You have the
pre-packaged database.
So when you're talking
about migrations,
for example, if the
pre-packaged database is
version 1 and the one that
you put in code is version 3,
Room will also have to handle
the migration from version 1
to version 3.

Korean: 
createFromAsset을 추가했습니다
createFromFile은 파일을 매개변수로 가져옵니다
다운로드하여 보유하고 있는 파일이죠
여기서 중요한 점은
파일에 View Permission을
설정해야 한다는 것입니다
그래야 Room이 파일을 읽어
데이터를 복사할 수 있거든요
그다음 데이터베이스를 APK에 사전 패키징한다면
이를 Assets 폴더에 저장해야 합니다
이전 작업의 경우도
그리 다르지 않습니다
일반적으로 Room에서는 두 가지를 확인해요
기기에 설치된 데이터베이스 버전을 확인하고
코드에 선언하는 버전을 확인하죠
즉 @Database 주석에 선언하는 버전을요
하지만 이제는 사전 패키징된
데이터베이스의 경우
주체가 하나 더 있습니다
사전 패키징된 데이터베이스가 있죠
그래서 이전의 경우
예를 들어 사전 패키징된 데이터베이스가
버전 1이고 코드에 입력한 버전이 3이라면
Room은 버전 1에서 버전 3으로의 이전도
처리해야 합니다

Indonesian: 
Ingatlah ini setiap saat
Anda menggunakan
database yang telah dipaketkan.
Fitur berikutnya adalah relasi.
Ini bukanlah hal baru
di Room, tapi di versi 2.2
kami meningkatkan
dukungan untuk relasi.
Jadi hari ini, mari lakukan
pembahasan singkat terkait hal ini.
Misalnya satu pemilik
hanya bisa punya satu anjing.
Memang sedih,
tapi anggaplah itu kenyataannya.
Ini artinya, terdapat relasi 1 banding 1
antara pemilik dan peliharaannya.
Dan relasi tersebut bisa diterjemahkan
menjadi database seperti ini.
Akan ada dua tabel,
tabel Pet dan tabel Owner.
Tabel Pet akan memiliki
referensi ke ownerId.
Untuk Room, ini artinya Anda
perlu membuat dua entitas, satu untuk
hewan peliharaan dan satu untuk pemilik.
Lalu, jika ingin
menerapkan batasan antara petOwnerId

Korean: 
사전 패키징된 데이터베이스로 작업할 때에는
이를 명심하시기 바랍니다
다음 기능은 관계입니다
Room에 새롭게 적용되는 것은 아니지만 2.2에서는
관계에 대한 지원을 확대했습니다
오늘은 이것이 무엇을 의미하는지
간략히 살펴보도록 하겠습니다
주인이 강아지 1마리만
가질 수 있다고 가정해 보죠
슬픈 일이지만 그런 세상에 살고 있다고
가정해 보는 거예요
즉, 일대일 관계가 성립해요
주인과 강아지 간에 말이죠
그럼 이렇게 데이터베이스로 변환됩니다
2개의 테이블
즉, Pet 테이블과 Owner 테이블이 있어요
Pet 테이블에는
OwnerId에 대한 참조도 있습니다
따라서 Room의 경우에는
강아지 항목과 주인 항목,
총 2개의 항목을 생성해야 해요
petOwnerId와 ownerId 간에
이러한 제약 조건을 실제로 실행하려면

English: 
So just keep this
in mind whenever
you're working with
pre-packaged databases.
Next feature is relations.
So this is not something new
for Room, but what we did in 2.2
is to increase the
support for relations.
So today, let's do a crash
course on what this means.
So let's say that an owner
can only have one dog.
This is a sad world,
but let's say that this
is where we're living.
So this means that
we have a 1 to 1
relation between the
owner and the pet.
And this can be translated
into database like this.
We would have two tables, a
Pet table and an Owner table.
And the Pet table
would also have
a reference to the ownerId.
For Room, this
means that you would
need to create two entities,
one for pets and one for owner.
And then, if you
actually really want
to enforce this constraint
between the petOwnerId

Japanese: 
パッケージ済みデータベースを
扱う場合は
その点を覚えておいてください
次の機能はリレーションです
新しい機能ではありませんが
2.2ではリレーションの
サポートを拡張しました
それがどういうことか
簡単に説明しようと思います
飼い主が１匹の犬しか
飼えないとしましょう
悲しいですが
そのような環境で
生活しているものとします
この場合
飼い主とペットとの
リレーションは１対１になります
データベースに変換すると
このように
PetテーブルとOwnerテーブルが
必要になります
Petテーブルには
ownerIDへの参照も必要です
Roomの場合は
ペットと飼い主の２つのエンティティを
作成する必要があります
petOwnerIdと
ownerIdの間に
制約を適用する場合は

Spanish: 
Tengan esto en cuenta
cuando trabajen
con bases de datos ya preparadas.
La siguiente función son las relaciones.
No es algo nuevo en Room,
pero en 2.2 incrementamos
la compatibilidad con relaciones.
Hoy, daremos un curso rápido
sobre el tema.
Supongamos que un dueño
puede tener un solo perro.
Ese sería un mundo cruel,
pero imaginemos que es así.
El resultado sería una relación
de 1 a 1 entre dueño y mascota.
Esto se traduce en la base de datos
de la siguiente manera.
Hay dos tablas: una para dueños (Owner)
y otra para mascotas (Pet).
Además, la tabla Pet tendría
una referencia al ownerId (ID del dueño).
Para Room, significa
que quieres crear dos entidades:
una para mascotas y una para dueños.
Luego, si quieren aplicar esta restricción

Portuguese: 
Portanto, tenha isso em mente sempre
ao trabalhar com bancos de dados
pré-empacotados.
O próximo recurso são as relações.
Esse recurso não é algo novo, 
mas o que fizemos na 2.2
foi aumentar a compatibilidade
para relações.
Hoje, vamos dar um curso intensivo
sobre o que isso significa.
Imaginem que um proprietário
só possa ter um cachorro.
É triste, mas vamos imaginar que
não exista outra forma.
Isso significa uma relação "1 para 1"
entre o proprietário e o
animal de estimação.
Isso pode se traduzido em
um banco de dados como este.
Teríamos duas tabelas: uma tabela
"Pet" e uma tabela "Owner".
A tabela "Pet" também teria
uma referência ao ownerId.
Para a Room, isso significa que
você teria que criar duas entidades:
uma para pets e outra para owner.
Depois, se quiser memso
aplicar essa restrição 
entre o petOwnerId

Chinese: 
当您处理预打包数据库的时候 请记住这一点
下一个功能是 关系 (Relations)
这不是 Room 中的新功能
不过我们在2.2版本中强化了对 Relations 功能的支持
今天 我们就来简要介绍一下这意味着什么
例如 一个主人只能拥有一条狗
这个限制真是糟心 不过我们先这么假设吧
这意味着 主人和宠物之间的关系是 1:1
转换成数据库应该是这样的
有两个表 分别是宠物表和主人表
宠物表还会有字段指向主人 ID
在 Room 中 这意味着你需要
为宠物和主人各创建一个实体
随后 如果你确实想要为 ownerId 和 petOwnerId
强制添加这个边界条件的话

Spanish: 
entre petOwnerId y ownerId,
pueden usar una clave externa.
Bien, ¿pero cómo obtenemos la lista
de todos los dueños con sus mascotas?
Si quieren hacerlo solo con SQLite,
deben seleccionar primero en Owner
y, luego, seleccionar en Pet
en función del ownerId.
El resultado se incluiría
en una clase de datos PetAndOwner
que incluye al dueño y a la mascota.
Con Room, pueden
anotar el dueño con "embedded"
y agregar la anotación "@Relation"
para la mascota.
Aunque la anotación
"@Relation" no es nueva,
en Room 2.2 ahora puede agregarse
a un objeto que no sea una colección.
Por ejemplo, aquí solo
la agregamos a la mascota
y le indicamos a Room
que hay una conexión
entre petOwnerId y ownerId.
Si lo desean, cuando escriban
su consulta en su dao,
solo tienen que seleccionar en Owner
para mostrar la lista PetAndOwner.

Portuguese: 
e o ownerId, 
poderia usar uma chave externa.
OK.
Então, como obtemos uma lista de
todos os proprietários com seus pets?
Bem, para fazer isso
usando apenas SQLite,
tem que, primeiro selecionar
em "Owner"e depois
em "Pet", com base no ownerId.
Isso seria colocado em uma
classe de dados,
uma classe PetAndOwner com
o owner e o pet.
Com a Room, você anotaria
o proprietário com código incorporado
e adicionaria a anotação
@Relation para o pet.
Embora a anotação @Relation
não seja nova,
o que é novo na Room 2.2 é o fato
de que você pode adicioná-la
a um objeto que
não seja uma coleção.
Por exemplo, nós a estamos
adicionando à tabela
"Pet" e dizendo à Room que há
uma conexão entre o código do
petOwnerId e o ownerId.
Se quiser, ao criar a consulta no DAO,
pode apenas selecionar em "Owner" e
retornar a lista de PetAndOwner.

English: 
and the ownerId, you
could use a foreign key.
OK.
But how do we get a list of
all the owners with their pets?
Well, if you want to do
this just using SQLite,
you would need to
select first from Owner,
and then you would
need to select
from Pet based on the ownerId.
So this would be put
inside a data class--
a PetAndOwner class that
has the owner and the pet.
With Room, you would annotate
the owner with embedded
and you would add the
@Relation annotation for pet.
So while this @Relation
annotation isn't new,
what is new in Room
2.2 is the fact
that you are able to add this
annotation to an object that
is not a collection.
So for example, here, we're
just adding it to the Pet
and we're telling
Room that there
is a connection between the
petOwnerId and the ownerId.
If you want to, when writing
your query in your dao,
you would just select
from Owner and you would
return the list of PetAndOwner.

Indonesian: 
dan ownerId, Anda dapat
menggunakan kunci asing.
Oke.
Tapi bagaimana cara mendapatkan daftar
semua pemilik dengan hewan peliharaannya?
Jika ingin melakukannya dengan SQLite,
Anda harus menulis
SELECT * FROM Owner
lalu SELECT * FROM Pet
berdasarkan ownerId.
Ini akan diletakkan
di dalam class data
class PetAndOwner
tempat Owner dan Pet berada.
Dengan Room, Anda akan memberikan
anotasi pada Owner dengan tersemat.
dan Anda akan
menambahkan anotasi @Relation untuk Pet.
Meskipun anotasi
@Relation tidaklah baru,
yang baru di Room 2.2 adalah
Anda dapat
menambahkan anotasi ini ke objek yang
bukan merupakan koleksi.
Misalnya, di sini kita
menambahkannya ke Pet
dan memberi tahu Room bahwa
ada hubungan antara
petOwnerId dan ownerId.
Jika mau, saat
menulis kueri di DAO,
Anda hanya perlu
menulis SELECT * FROM Owner
dan daftar PetAndOwner akan ditampilkan.

Japanese: 
外部キーを使用するとよいでしょう
さて ところで
ペットと飼い主のリストをすべて
取得するにはどうしますか？
その場合は
SQLiteを使い
まずOwnerからSELECTし
ownerIdに基づき
PetからSELECTする必要があります
さて このデータをデータクラスの
PetAndOwnerに
記述することにします
Roomを使う場合
飼い主に@Embeddedを
ペットに@Relationを付けます
@Relationは
以前からありますが
Room2.2では
コレクション以外のオブジェクトに
付けられるようになりました
ここではPetに付けることで
petOwnerIdとownerIdの間に
関係があることをRoomに伝えています
DAOでクエリを記述する際は
OwnerからSELECTするだけで
PetAndOwnerのリストを
返すことができます

Korean: 
외래 키를 사용하면 됩니다
그렇다면
주인과 강아지의 전체 목록을
어떻게 얻을 수 있을까요?
SQLite를 사용하면
우선 Owner에서 선택하고
ownerId에 따라 Pet에서
선택해야 합니다
이렇게 하면 데이터 클래스에 들어갈 거예요
주인과 강아지가 포함된
PetAndOwner 클래스에 들어가는 거죠
Room의 경우에는 owner에
embedded 주석을 달고
pet에는 @Relation 주석을 추가합니다
@Relation 주석은 새롭지 않지만
Room 2.2의 새로운 기능은
컬렉션이 아닌 객체에 주석을
추가할 수 있다는 거예요
예를 들어 이 경우에 Pet에 주석을
추가하기만 하면
Room이 인식할 수 있다는 거예요
petOwnerId와 ownerId 간에
관계가 있다는 것을 말이죠
원한다면 DAO에 쿼리를 작성할 때
Owner에서 선택하여
PetAndOwner 목록을 반환할 수 있습니다

Chinese: 
那么你就可以使用 ForeignKey
好 那么我们要如何获取内含所有主人及其宠物的列表呢？
如果你想这么做 请使用 SQLite
你需要先 SELECT * FROM Owner
然后你需要基于 OwnerId 再 SELECT * FROM Pet
这些东西会被放进一个数据类里
PetAndOwner 类 其中包含主人和宠物
在 Room 的帮助下 你可以将 Owner 注解为 Embedded
然后你可以为 Pet 添加 @Relation 注解
这个 @Relation 注解不是什么新鲜东西
Room 2.2 里真正的新东西是
现在你可以为非集合对象添加这个注解
例如 在这里 我们就可以把它添加到 Pet 
并告知 Room petOwnerId 和 ownerId 之间是有关系的
当你在 Dao 中编写查询时 只要你愿意
你就可以 SELECT * FROM Owner
并返回 PetAndOwner 列表

Portuguese: 
OK.
Dissemos que um proprietário
tem um cachorro.
E se o proprietário puder
ter vários cachorros?
Essa relação seria "1 para vários"
e seria mapeada da mesma maneira
no seu banco de dados.
Você ainda teria um
cachorro e um proprietário.
Então, quando quisermos ver
a lista de proprietários com
seus pets, as consultas
que precisariam ser criadas
seriam as mesmas.
Você ainda precisaria
selecionar em "Owner"
e depois em "Pet".
Mas não queremos fazer isso manualmente.
Queremos usar a Room.
Criaremos nossa classe de dados,
"OwnerWithPets",
em que ainda teremos o Owner
e a anotação @Relation na lista de Pets.
Então, aqui na
anotação @Relation,
estamos dizendo que há uma conexão
entre o proprietário do pet
na tabela "Pet"
e a coluna de ownerId
na tabela "Owner".
Nossa consulta é simples.
É só SELECIONAR EM "Owner",
retornando
uma lista "OwnerWithPets".

Chinese: 
好 正如我们所说 一个主人拥有一条狗
那么假如一个主人能拥有好几条狗呢？
这就是一对多关系
在你的数据库里 这个关系也是按照同样的方式来注明的
仍然存在着宠物和主人这两个项目
当我们想要获取主人及其所有宠物的列表时
你需要编写的查询其实是不用改变的
你仍然要从 Owner 和 Pet 中 SELECT
但是我们不想用手动的方式来做这件事
而是想使用 Room 来帮忙
我们会编写我们的数据类 OwnerWithPets
这个类中仍然会有 @Embeded 的 Owner 
并在 Pet 列表上添加 @Relation 注解
在 @Relation 注解中
我们发现 Pet 表的宠物主人
和 Owner 表单上的 ownerId 列之间是有关系的
我们的查询很简单：
SELECT * FROM Owner 返回 OwnerWithPets 列表

Korean: 
지금까지
주인 1명이 강아지 1마리를
가진다고 가정했어요
주인 1명이 강아지 여러 마리를
가진다면 어떻게 될까요?
이는 일대다 관계가 됩니다
그리고 같은 방식으로 데이터베이스에
매핑됩니다
따라서 여전히 강아지 1마리와
주인 1명이 있게 되죠
주인과 모든 강아지 목록을 원한다면
작성해야 하는 쿼리는
사실 동일합니다
Owner에서 선택하고 나서
Pet에서 선택해야 합니다
하지만 직접 수동으로 선택하는 대신
Room을 사용하려 합니다
OwnerWithPets 데이터 클래스를
작성합니다
여전히 owner가 embedded 상태이고
Pet 목록에는 @Relation 주석이 달려있죠
그래서 여기에서 @Relation 주석은
Pet 테이블의 강아지 주인과
Owner 테이블의 ownerId 열 간에
관계가 있다는 것을 보여줍니다
쿼리는 간단합니다
SELECT FROM Owner라고 작성하여
OwnerWithPets 목록을 반환합니다

English: 
OK.
So we said that an
owner has a dog.
What if an owner can
have multiple dogs?
So this will be a
1 to many relation,
and this is mapped in the
same way in your database.
So you still have
a pet and an owner.
And then, when we want
to get the list of owners
with all of their pets, the
queries that you need to write
are actually the same.
You still need to
select from Owner
and then you would need
to select from Pet.
But we don't want
to do this by hand.
We want to use Room.
So we will write our data
class, OwnerWithPets,
where we would still
have the owner embedded
and the @Relation annotation
on the list of Pet.
So here, in the
@Relation annotation,
we're saying that
there is a connection
between the pet owner
of the Pet table
and the ownerId column
of the Owner table.
Our query is simple.
It's just SELECT
FROM Owner, returning
a list of OwnerWithPets.

Spanish: 
Bien.
Dijimos que cada dueño tiene un perro.
¿Qué pasaría si un dueño
puede tener varios perros?
Esta sería una relación de 1 a varios
y se mapea de la misma manera
en la base de datos.
Todavía tendrán una mascota y un dueño.
Y, cuando quieran
ver la lista de dueños y mascotas,
las consultas
que deberán escribir serán las mismas.
Nuevamente deberán seleccionar
en Owner y, luego, en Pet.
Pero no queremos hacerlo manualmente,
sino con Room.
Entonces, escribiremos
nuestra clase de datos, OwnerWithPets,
en la que todavía
tendremos al dueño incorporado
y la anotación @Relation
en la lista de mascotas.
En la anotación @Relation,
indicaremos que hay una conexión
entre el dueño de la mascota
de la tabla Pet
y la columna ownerId
de la tabla de dueños.
Nuestra consulta es simple.
Solo queremos SELECT FROM Owner
y mostrar la lista de OwnerWithPets.

Indonesian: 
Oke.
Telah disebutkan bahwa
satu pemilik punya satu anjing.
Bagaimana jika satu pemilik
bisa punya beberapa anjing?
Ini akan menjadi
relasi 1 banding banyak,
dan ini dipetakan dengan
cara yang sama di database.
Jadi, akan tetap
ada satu Pet dan Owner.
Lalu, saat ingin
mendapatkan daftar pemilik
dengan semua hewan
peliharaannya, kueri yang perlu ditulis
sebenarnya sama.
Anda harus menulis
SELECT * FROM Owner,
lalu SELECT * FROM Pet.
Namun kita tidak
ingin melakukannya sendiri.
Kita ingin
menggunakan Room.
Kita akan menulis
data class OwnerWithPets,
tempat owner
akan tetap tersemat
dan anotasi @Relation
di List akan tetap ada.
Di sini, di anotasi @Relation,
kami katakan bahwa terdapat hubungan
antara petOwner di tabel Pet
dan kolom ownerId di tabel Owner.
Kueri kita sangat sederhana.
Hanya SELECT * FROM
Owner, yang menampilkan
List

Japanese: 
ここまでは
飼い主が飼っている犬は
１匹でした
飼い主が複数の犬を
飼っていたらどうでしょう？
その場合は
１対多のリレーションになり
データベースで同じように
マッピングします
ペットと飼い主は先ほどと同じです
飼い主のリストをそのペットとともに
取得する場合
作成する必要があるクエリは同じです
OwnerからSELECTして
PetからSELECTする必要があります
しかし これを手動で行わずに
Roomを使用したいと思います
そこで
データクラスOwnerWithPetsを
定義して
飼い主に@Embeddedを
ペットのリストに@Relationを付けます
@Relationアノテーション内では
Petテーブルの飼い主と
Onwerテーブルの
ownerId列の間に
関係があると宣言しています
クエリは簡単で
OwnerからSELECTすれば

English: 
OK.
So we have an owner
having multiple pets.
But what if a pet can
have multiple owners?
Well, in this case, we have
a many to many relation.
And unfortunately, this
can't be expressed simply
with two tables.
But rather, what
we need to do is
to create a junction--
a link table.
A PetOwner table that
contains the IDs of the pet
and of its owner.
So the pet owner
would be an entity
with a composite primary
key, the pet and the owner.
But now, if we want to create
a list of all the owners
with all of their pets,
things look like this.
So first, we would need
to select from the owner,
and then we would need
to write the query that
creates an inner join between
the Pet and the Junction table.
So this is quite a lot
of queries to write
for this amount of data.

Chinese: 
好 现在一个主人拥有多个宠物的情况已经讨论过了
那么 假如一个宠物拥有多个主人会怎样？
在这种情况下 就是所谓多对多关系
不幸的是 这种关系 用两个表是解释不清的
我们需要做的是 创建一个桥梁 也就是连接表
一个内含宠物 ID 和相应主人 ID 的 PetOwner 表
PetOwner 是一个拥有复合式 primaryKey 的实体
其中包括宠物和主人
但是 如果我们想要创建内含所有主人及其宠物的列表
情况就会变成这样
首先 我们需 SELECT * FROM Owner
然后需要编写查询 
这个查询需要在宠物和连接表之间创建出内部联系
仅仅为了这点数据 需要编写的查询看起来似乎太多了
但是 在 Room 的协助下 我们可以改善这一处境

Japanese: 
OwnerWithPetsのリストが返されます
さて これで
飼い主が複数のペットを
飼えるようになりました
しかし ペットに複数の主人がいたら
どうなるでしょう？
その場合は
多対多のリレーションを作ります
しかし これは２つのテーブルで
シンプルに
表現できません
そこで
リンクテーブルを
つまり
ペットと飼い主の
IDを保持する
PetOwnerテーブルを
作成する必要があります
そこで
飼い主をエンティティとして定義し
ペットと飼い主を
複合主キーとして指定します
さて すべての飼い主と
ペットのリストを
作成する場合は
次のように処理します
まずOwnerからSELECTしてから
Petテーブルとリンクテーブルを
内部結合するクエリを作成する
必要があります
このようにデータが大量だと
多くのクエリを作成する必要が
あります

Portuguese: 
OK.
Então, temos um proprietário
com vários pets.
E se um pet puder ter
vários proprietários?
Nesse caso, teríamos uma relação
"muitos para muitos".
Infelizmente, isso não pode
ser expresso simplesmente
com duas tabelas.
O que precisamos fazer é
criar uma junção, uma tabela vinculada.
Uma tabela "PetOwner" que
contenha os IDs do pet
e do respectivo proprietário.
Assim, o proprietário do pet
teria uma entidade
com uma chave primária composta:
o pet e o proprietário.
Se quisermos criar uma lista
de todos os proprietários
com todos os seus pets,
teríamos isto.
Primeiro, precisaríamos
selecionar em Owner
e depois gravar a consulta que
cria uma ligação interna entre
as tabelas "Pet" e a de junção.
Seriam muitas consultas para criar
para esse volume de dados.

Korean: 
이제
강아지 여러 마리를 가진 주인이 있어요
그런데 강아지 1마리의 주인이
여러 명이라면 어떨까요?
이 경우에는 다대다 관계가 됩니다
안타깝게도 이러한 관계는 테이블 2개로만
나타낼 수가 없습니다
대신 정션 테이블, 즉 링크 테이블을
생성해야 합니다
PetOwner 테이블에 강아지와 주인의 ID가
포함되어 있는 거죠
강아지 주인은 강아지와 주인이라는
복합 기본 키를 가진 항목이 됩니다
하지만 모든 주인과
모든 강아지의 목록을 생성하려면
코드는 이와 같을 것입니다
우선 주인 중에서 선택한 다음
쿼리를 작성해야 하죠
Pet과 정션 테이블 간
내부 조인을 생성하는 쿼리를요
데이터 양에 비해 작성해야 할 쿼리가
너무 많아요

Indonesian: 
Oke.
Jadi ada satu pemilik
dengan beberapa hewan peliharaan.
Namun bagaimana jika satu hewan
bisa punya beberapa pemilik?
Dalam kasus ini terdapat
relasi banyak banding banyak.
Dan sayangnya, ini tidak
dapat diekspresikan dengan
hanya dua tabel.
Tapi, yang perlu dilakukan yakni
membuat simpangan, suatu tabel link.
Tabel PetOwner yang berisi ID hewan
dan pemiliknya.
Jadi, PetOwner akan menjadi entitas
dengan kunci utama
gabungan, yaitu hewan dan pemiliknya.
Namun, jika ingin
membuat daftar semua pemilik
dengan semua hewan peliharaannya,
tampilannya akan seperti ini.
Pertama, kita harus
menulis SELECT * FROM Owner,
lalu kita harus
menulis kueri yang
akan membuat inner join
antara Pet dan tabel Simpangan.
Kueri ini cukup
panjang untuk ditulis
bagi data sebanyak ini.

Spanish: 
Bien.
Tenemos un dueño con varias mascotas.
¿Y si una mascota tuviera varios dueños?
En ese caso, tenemos
una relación de varios a varios
y, lamentablemente, no podemos
expresarla con solo dos tablas,
sino que debemos crear
una conjunción, una tabla de vínculo.
Es decir, una tabla PetOwner
que contenga los ID de la mascota
y el de su dueño.
El PetOwner será una entidad
con una clave primaria compuesta:
la mascota y el dueño.
Ahora, si quisiéramos
crear la lista de todos los dueños
y todas las mascotas, esta se vería así.
Primero, debemos seleccionar en Owner
y, luego, escribir la consulta
que creará una unión interna
entre la mascota y la tabla de conjunción.
Deben escribirse varias consultas
para esta cantidad de datos.

Spanish: 
Por eso, con Room, ahora
podemos escribirlas de otra manera.
Aún usaríamos los datos de OwnerWithPets
que definimos antes,
con un dueño y su lista de mascotas.
También deben anotarlo
con @Embedded y @Relation.
Pero la diferencia aquí
es la etiqueta associateBy en @Relation.
Esta le indica a Room
que debe conectar las mascotas y el dueño
según la tabla de conjunción:
PetsAndOwner.
En el dao, debemos escribir
la consulta, usar SELECT FROM Owner
y mostrar la lista de OwnerWithPets.
Por lo tanto, en Room 2.2
con una anotación @Relation,
pueden admitir relaciones de 1 a 1,
de 1 a varios y de varios a varios.
Danny, ¿queda tiempo para más funciones?
Sí. Así es.
Hay más funciones.
En Room 2.2, también agregamos
los valores predeterminados.

Korean: 
그래서 Room에서는
다른 방식으로 작성할 수 있죠
OwnerWithPets 데이터를
그대로 사용할 수 있어요
이전에 주인과 강아지 목록에서
정의했던 것으로요
@Embedded와 @Relation 주석도 추가합니다
그런데 @Relation의 associateBy 태그는
무엇이 다를까요?
이 태그는 Room에게
강아지와 주인을 연결하라는 지시를 내려요
PetsAndOwner라는 정션 테이블에 따라 말이죠
이제 DAO에
SELECT FROM Owner 쿼리를 작성하여
OwnerWithPets 목록을
반환하기만 하면 됩니다
즉, Room 2.2에서는
@Relation 주석을 통해
일대일, 일대다, 다대다 관계를
지원합니다
대니, 기능이 더 있나요?
네
있습니다
기능이 더 있어요
Room 2.2에 기본값을 추가했어요

English: 
So now, with Room, we can
write things differently.
So we would still use the
same OwnerWithPets data
that we've defined before with
our owner and our list of pets.
Also annotate it with
@Embedded and @Relation.
But what is different is this
associateBy tag in @Relation.
So this is the one
that tells Room
that, OK, you should connect
the pets and the owner
based on this junction
table, PetsAndOwner.
So now, in the dao,
we need to just write
our query, SELECT
FROM Owner, and return
the list of OwnerWithPets.
So this means that,
now, in Room 2.2,
with one annotation, @Relation,
we can support 1 to 1,
1 to many, and many
to many relations.
OK, Danny, is there
room for more features?
DANIEL SANTIAGO RIVERA: Yes.
Yes, there is.
There's more features.
Another thing we added in
Room 2.2 was default values.

Japanese: 
Roomを使うと
別の方法でこれを行えます
飼い主とペットのリストで
先に定義した
OwnerWithPetsを使用します
@Embeddedと@Relationも付けますが
@RelationのassociateByタグが
違います
これにより
リンクテーブルの
PetsAndOwnerに基づいて
ペットと飼い主を
関連付けよとRoomに指示します
次にDAOでクエリを
SELECT * FROM Ownerと記述し
OwnerWithPetsを返します
このように
Room 2.2では
@Relationアノテーション１つで
１対１
１対多、多対多の
リレーションを定義できます
Danny
他にまだ追加機能はありますか？
はい
そうですね
他にもまだ機能はあります
Room 2.2では既定値を追加しました

Portuguese: 
Agora, com a Room, podemos criar
as coisas de forma diferente.
Ainda usaremos os mesmos dados
de "OwnerWithPets"
que definimos antes com nosso
owner e nossa lista pets.
Também faremos a anotação com
@Embedded e @Relation.
Diferente aqui é a tag
"associateBy" em @Relation.
É ela que diz para a Room
que você pode conectar
pets com owner,
com base na tabela "PetsAndOwner".
Agora, no DAO, só precisamos criar
a consulta, SELECIONAR EM
"Owner" e retornar
a lista de "OwnerWithPets".
Isso significa que agora, na Room 2.2,
com uma única anotação, @Relation,
podemos ter as relações
"1 para 1", "1 para muitos" e
"muitos para muitos".
OK, Danny, podemos ver mais recursos?
Sim.
Sim, podemos.
Temos mais recursos.
Também adicionamos na Room 2.2
valores padrões.

Indonesian: 
Dengan Room, kini kita
dapat menulis dengan cara berbeda.
Kita akan tetap menggunakan
data OwnerWithPets yang sama
yang telah kita tentukan
dengan Owner dan List.
Selain itu, membuat
anotasi @Embedded dan @Relation.
Namun yang berbeda
adalah tag associateBy di @Relation.
Ini adalah tag yang
memberi tahu Room
bahwa Anda harus
menghubungkan Pet dengan Owner
berdasarkan tabel
simpangan PetsAndOwner.
Di DAO, kini kita
hanya perlu menulis
kueri, SELECT * FROM
Owner, dan menampilkan
List.
Ini artinya, kini di Room 2.2,
dengan anotasi @Relation, kita
dapat mendukung relasi 1 banding 1,
1 banding banyak, dan
banyak banding banyak.
Oke, Danny, apa masih
bisa menambahkan fitur lain?
-Ya.
Tentu bisa.
Ada banyak fitur lain.
Hal lain yang kami tambahkan
di Room 2.2 adalah nilai default.

Chinese: 
我们仍会使用相同的 OwnerWithPets 数据
这些数据是我们之前使用主人和宠物名单定义过的
此外 还同样使用了 @Embeded 和 @Relation 进行注解
但不同之处就体现在 在 @Relation 中的这个
associateBy 字段
就是它告知 Room:
你应该根据 PetsAndOwner 这个连接表来连接宠物和主人
现在 在 Dao 中 我们只需编写查询
SELECT * FROM Owner 
然后返回 OwnerWithPets 列表
这意味着 如今在 Room 2.2 中
随着 @Relation 这个注解的加入
我们现在能够支持一对一 一对多 和多对多关系
好 Danny 还有时间来介绍更多功能吗？
有 还有更多功能
我们在 Room 2.2 中加入的另一个东西就是默认值
不是耦合默认值 而是 Schema 默认值

English: 
Not coupling default values,
schema default values.
And you can find this in the
column in Flow annotation.
There's a new property
called defaultValue.
And this actually takes
an SQLite expression.
So you can use things
like [INAUDIBLE]
which is a keyword on SQLite.
Another thing we added in Room
2.2, or we made in Room 2.2,
was a gradle incremental
annotation processor.
And this is
basically a change we
did so that you can
get some build benefits
when you're continuously
building your application.
You have to opt in
into this feature.
It's Annotation Processor flag.
We want to enable it by
default in the future,
but we're in this phase
where we're trying it out,
hashing out any issues.
So please try it out.
Let us know if it works or not.
The last feature we had room for
was kind of like a long-lasting
bug--

Portuguese: 
Não valores padrão de acoplamento,
mas de esquemas.
Vocês podem encontrar isso na
coluna da anotação do Flow.
Há uma nova propriedade, 
chamada "defaultValue",
Ela assume uma expressão SQLIte.
Podemos usar coisas como [INAUDÍVEL],
uma palavra-chave em SQLIte.
Adicionamos também na Room 2.2,
ou criamos na Room 2.2,
um processador de anotação
incremental do Gradle.
Fizemos essa mudança para
que vocês tenham
vários benefícios na compilação
quando estiverem criando
seu app continuamente.
Vocês precisam ativar esse recurso.
É a flag "Annotation Processor".
Queremos fazer com que ela
seja ativada por padrão no futuro.
Mas, estamos nessa fase de testes,
resolvendo possíveis problemas.
Façam os testes e
conte-nos se funciona ou não.
O último recurso que incluímos
na Room era um antigo bug,

Korean: 
결합 기본값이 아닌 스키마 기본값으로 말이죠
ColumnInfo 주석에서 기본값을 확인할 수 있어요
defaultValue라는 새로운 속성이 있는데
사실 SQLite 표현식이 적용된 거죠
그래서 SQLite의 키워드인 시간 유형을
사용할 수 있습니다
Room 2.2에 추가된 또 다른 기능은
Gradle 증분 주석 프로세서로
지속적으로 애플리케이션을 제작할 때
빌드에 도움이 될 수 있도록
변경한 부분입니다
이 기능을 선택해야 합니다
주석 프로세서 플래그입니다
향후에 이를 기본값으로 실행하고자 하지만
지금은 시도해 보고 문제를 해결해 나가는
단계에 있습니다
한 번 사용해 보시고
장단점을 알려주시면 감사하겠습니다
마지막 Room의 기능은 지속적인
버그, 아니

Indonesian: 
Bukan nilai default
berpasangan, tapi nilai default skema.
Dan Anda dapat
menentukannya di anotasi @ColumnInfo.
Ada properti baru, yakni defaultValue.
Dan ini memerlukan ekspresi SQLite.
Anda dapat
menggunakan fitur seperti [...],
yang merupakan
kata kunci di SQLite.
Hal lain yang kami
tambahkan atau buat di Room 2.2
adalah prosesor
anotasi inkremental gradle.
Ini adalah perubahan yang
kami lakukan agar Anda
mendapatkan manfaat build
saat membuat aplikasi secara berlanjut.
Anda harus menyatakan
keikutsertaan dalam fitur ini.
Ini adalah flag Prosesor Anotasi.
Kami ingin mengaktifkannya
secara default untuk selanjutnya,
namun kami masih
berada di fase percobaan,
mengatasi masalah yang ada.
Harap Anda coba.
Beri tahu kami hasilnya nanti.
Fitur terakhir yang dapat disempurnakan
adalah bug yang berlangsung lama.

Chinese: 
大家可以在 @ColumnInfo 里定义它
那里加入了一个字段叫 defaultValue
它接收 SQLite 表达式
因此你可以使用如 CURRENT_TIMESTAMP 这样的 SQLite 关键词
我们在 Room 2.2 中加入的另一个东西是
Gradle 增量注解处理器
我们这样改进 是为了方便你在不断构建应用的时候
可以获得一些构建优化
这个功能必须手动打开
它是注解处理器的一个开关值
将来我们希望能默认启用它
但目前它还处在试用和除错阶段
所以 欢迎大家试用 并为我们提供反馈信息
我们为 Room 加入的最后一个功能
有点像是一个长期持续的 bug

Japanese: 
Kotlin既定値ではなく
スキーマ既定値です
これはColumnInfoアノテーションの
中にあります
defaultValueという
新しいプロパティがあります
これはSQLiteの式を受け取るので
SQLiteのキーワードである
CURRENT_TIMESTAMPなどを
使えます
また Room 2.2では
Gradleインクリメンタル
アノテーションプロセッサーを
追加しました
このような変更を加えたのは
継続的にアプリケーションを
ビルドする場合に
恩恵を得られるようにするためです
使用するには
プロセッサーの
フラグを有効にする必要があります
将来的には既定で有効にしたいと
考えていますが
今はテストして問題がないか
検討している段階です
ぜひお試しいただき
機能するか教えてください
最後の機能は
かなり前から知られていた
バグに関係します

Spanish: 
No valores predeterminados
de acoplamiento, sino de Schema.
Pueden definirlos
en la columna de la anotación Flow.
Hay una nueva propiedad, 
llamada defaultValue,
que toma una expresión SQLite
para que puedan usar,
por ejemplo, "CURRENT_TIME"
que es una palabra clave de SQLite.
Otro elemento que agregamos en Room 2.2
es el procesador
de anotaciones incrementales de Gradle.
Este es un cambio que tiene como fin
darles ventajas de compilación
cuando desarrollan
su aplicación de manera continua.
Tienen que habilitar esta función.
Es la etiqueta "Annotation Processor".
Queremos habilitarla
de manera predeterminada en el futuro,
pero aún estamos en la fase de prueba,
corrigiendo los errores.
Pruébenla y cuéntennos si funciona.
La última función que puedo explicar
es un error muy antiguo,

Indonesian: 
Mungkin bukan bug,
tapi masalah berkepanjangan
saat menghadapi
subdaftar dari kolom.
Misalnya kita
memiliki entitas Dog.
Ini memiliki beberapa
properti dan [...] yang lebih kecil
yang memiliki
subhimpunan untuk entitas ini.
Jika mencoba membuat
kueri untuk tabel Dog
namun menampilkan List, Anda
akan mendapatkan peringatan dari Room,
yang mengatakan bahwa kueri
Anda memiliki terlalu banyak kolom.
Jadi, akan ditampilkan terlalu
banyak kolom yang tidak perlu.
Ini terjadi karena
kita menggunakan
proyeksi bintang.
Untuk Room 2.2,
kami tambahkan fitur
yang akan
mengambil proyeksi bintang
dan menulisnya ulang
hanya ke kolom yang dibutuhkan.
Dan Anda mendapatkan manfat build,
dan keuntungan performa secara gratis.
Ini disebut proyeksi perluasan.
Ini adalah fitur eksperimental.
Jadi, cobalah fitur ini
dan beri tahu kami hasilnya.

English: 
or not a bug, but
like a long issue
of dealing with a
sublist of columns.
So imagine we had
this entity, Dog.
It has a bunch of properties
and a smaller [INAUDIBLE]
for it which has
a subset for it.
If you try to query
the Dogs table
but return a puppy, you will
get a warning from Room, telling
you, hey, your query
has too many columns.
So it's returning too many
columns that you don't need.
And the reason this
is happening is
because we were using
that star projection.
With Room 2.2, we
added a feature
that will actually
take star projection
and rewrite it just to
the columns that you need.
And you get that build
benefit, that performance
benefit kind of for free.
We call this
expanding projections.
It's an experimental feature.
So try it out and let
us know how it goes.
To enable it, you have to go
to your Annotation Processor

Japanese: 
バグというよりは
列のサブリストを扱うときの問題です
Dogというエンティティに
多数のプロパティと
そのサブセットを持つ小さな
POJOがあるとしましょう
dogsテーブルをクエリして
子犬を返すと
クエリの列が多すぎるという
警告が出されます
これは 返される列に
不要なものが多すぎるからです
これが起きるのは
スター投影を
使用しているからです
Room 2.2では
スター投影を必要な列に
書き換える機能が追加されました
これにより
ビルドやパフォーマンス上の
メリットがコストなしで得られます
これは拡張投影と呼ばれる
試験的な機能です
ぜひ試していただき
その結果どうなったかを
教えていただければと思います
これを有効にするには
アノテーションプロセッサーの

Korean: 
버그가 아니고 지속적인 문제예요
열의 하위 목록을 처리하는 데
따르는 문제죠
Dog라는 항목이 있다고 가정해 보죠
이 항목에는 많은 속성이 있고
여기에는 하위 세트가 있습니다
Dog 테이블을 쿼리하려 하지만
강아지 1마리를 반환하는 경우
Room에서 경고를 보냅니다
쿼리에 열이 너무 많다고 말이죠
불필요한 열이 너무 많이 반환되는 거죠
이런 일이 발생하는 이유는
별표 투영을 사용했기 때문입니다
Room 2.2에는
별표 투영을 사용하여
필요한 열에만 재작성하는
기능이 추가되었습니다
빌드와 성능 혜택을
거저 얻을 수 있는 거죠
이를 확장 투영이라고 하는데
아직 시험 단계에 있는 기능이기 때문에
한번 사용해 보시고 어떤지 알려주시기 바랍니다
확장 투영을 실행하려면
주석 프로세서 옵션으로 이동하여

Chinese: 
或者说是一个与处理列的子集有关的问题
假如我们有一个主体 名叫 Dog (狗)
它拥有一些属性 还有一个 POJO
并拥有其中的一些属性
如果你想要查询 Dog 表
但返回小狗类型的结果
这时你就会收到由 Room 发出的警报：
嘿 你查询的字段太多了
它返回了太多你不需要的
之所以会这样 原因在于 我们使用了 * 投影
在 Room 2.2 中 我们添加了一个功能
可以重写 * 改为只查询你需要的字段
这样你就几乎毫不费力地获取了构建时的性能优化
我们将其称为 Expand Projections
这个功能仍处于试验阶段
所以 请大家踊跃尝试 把结果告诉我们
为了启用它 你需要前往注解处理器选项

Spanish: 
o más bien un problema
para administrar sublistas de columnas.
Imaginemos que tenemos
la entidad "Dog" (perro)
que tiene varias propiedades
y un POJO más pequeño,
para la que tiene un subconjunto.
Si crean una consulta para la tabla "Dogs"
pero aparece un "Puppy" (cachorro),
verán una advertencia de Room
en la que se indicará que la consulta
tiene demasiadas columnas.
Entonces, muestra
muchas columnas que no necesitamos.
Este problema se debe a que usamos
la proyección destacada.
En Room 2.2, agregamos una función
que tomará la proyección destacada
y la reescribirá para que tenga
solo las columnas que necesitan.
Pueden obtener ese beneficio
de compilación y rendimiento gratis.
Lo llamamos proyecciones desplegables.
Es una función experimental.
Pruébenla y cuéntennos cómo funciona.
Para habilitarla, vayan a las opciones
de Annotation Processor

Portuguese: 
não exatamente um bug
mas um problema antigo:
lidar com uma sublista de colunas.
Imagine esta entidade, "Dog".
Ela tem várias propriedades
e um [INAUDÍVEL] menor
que tem um subconjunto delas.
Se você tentar consultar
a tabela "Dogs",
mas ela retornar um filhote,
receberá um aviso da Room,
dizendo que sua consulta tem
muitas colunas.
Ela está retornando muitas
colunas desnecessárias.
Isso acontece porque
estávamos usando essa projeção em estrela.
Na Room 2.2, incluímos um recurso
que, de fato, usa projeção em estrela
e a recria apenas para as
colunas necessárias.
E tem esses benefícios de compilação,
e de desempenho
quase que gratuitamente.
Chamamos isso de
"Projeções de expansão".
É um recurso experimental.
Teste-o e conte-nos como ele funciona.
Para ativá-lo, acesse suas
opções do processador de anotações

English: 
options and also
up in via a flag.
Expanding projections,
although, also
tackles the long-lasting issue
of conflicting column names.
And you could see
this a lot if you
tried to do a join of
two tables that had
two columns with the same name.
For example, here, we
have Dogs and Owners
and they both have
a column name ID.
Expanding projections
solve this because you
can define a [INAUDIBLE] and you
can use embedded with prefixes.
And if you combine the prefix
along with the SQLite operation
to rename the table,
then Room will figure out
which column goes
to which entity
and he will be able to
rewrite your projections so
that there's no
conflicting columns.
So this makes it
easier for those
queries with big joins that
have conflicting names.
As you keep adding
more things, you

Portuguese: 
ou por uma sinalização.
O "Projeções de expansão" também
rastreia o antigo problema
de nomes de colunas conflitantes.
Isso acontecia bastante quando
tentávamos fazer uma junção de
duas tabelas e tínhamos duas
colunas com o mesmo nome.
Por exemplo, aqui temos
"Dogs" e "Owners",
com o mesmo código de nome de coluna.
O "Projeções de expansão" resolve isso,
porque você
pode definir um [INAUDÍVEL] e usar código
incorporado com prefixos.
Se você combinar o prefixo com
a operação do SQLite
para renomear a tabela, a Room detectará
a coluna correspondente a uma entidade
e poderá recriar suas projeções para
que não haja colunas conflitantes.
Isso facilita as consultas que têm grandes
junções com nomes conflitantes.

Spanish: 
y agregarla con una marca.
Las proyecciones desplegables
también resuelven el antiguo problema
de nombres de columnas conflictivos.
Este solía ocurrir
cuando intentaban unir dos tablas
que tenían dos columnas
con el mismo nombre.
Por ejemplo, aquí tenemos Dogs y Owners,
y ambas tienen la columna "Name ID".
Las proyecciones desplegables
resuelven este problema
porque les permiten definir un POJO
y usar prefijos incorporados.
Si combinan el prefijo
con la operación de SQLite
para renombrar la tabla, Room notará
qué columna corresponde a cada entidad
y podrá reescribir sus proyecciones
para que no haya columnas conflictivas.
De esta manera, es más fácil
usar consultas que unen
muchos elementos con nombres conflictivos.
A medida que agreguen más elementos,

Japanese: 
オプションに移動し
フラグをオンにします
また
拡張投影は
以前からあった列名の競合の問題を
解決するためのものです
この問題は
同名の列を持つ
２つのテーブルを結合するときに
何度も経験したと思います
このDogsとOwnersには
idという列が両方にあります
拡張投影を使うと
これを解決できます
POJOを定義して
埋め込みと接頭辞を使えるからです
接頭辞と
テーブル名を変更するSQLiteの処理を
組み合わせれば
Roomが列とエンティティの
対応関係を割り出して
列の競合が発生しないように
投影を書き換えます
これにより
名前の競合が生じる
大規模な結合を行うクエリを
容易化できます
結合対象を増やしても
スター投影を

Chinese: 
并通过这个开关启用它
Expand Projections 还解决了长期以来的一个问题：
列名称冲突
如果你曾经试图连起两个带有两个相同列名的表
你就会发现 这种现象相当常见
例如 这里我们可以看到 Dogs 和 Owners
它们都拥有着一个列叫 ID
Expand Projections 解决了这个问题
因为你可以定义一个 POJO
并使用带 prefix 的 @Embeded 字段
如果你把 prefix 和 SQLite 操作结合起来
并重命名这个表单的话
Room 就会知道出哪个列属于哪个实体
并重写你的投影
从而解决列名称冲突的问题
这就可以让你更加轻松地面对那些
拥有很多命名冲突的大型连接查询
让你在添加更多东西的时候

Korean: 
플래그를 통해 올라가야 합니다
또한 확장 투영은
열 이름 충돌이라는
지속적인 문제도 해결합니다
흔히 일어나는 현상으로
이름이 동일한 두 열이 포함되어 있는
두 테이블을 합치려고 할 때 일어나죠
예를 들어 여기에 Dogs와 Owners가 있고
둘 다 열 이름 ID가 있습니다
확장 투영을 사용해서
문제를 해결할 수 있는데
Embedded에 접두어를 붙여
사용할 수 있기 때문이죠
접두어를 SQLite 연산에 결합하여
테이블 이름을 변경하면 Room은
어떤 열이 어떤 항목에 연결되는지 파악하여
열이 충돌하지 않도록
투영을 재작성할 수 있습니다
따라서 충돌하는 이름이 포함된
규모가 큰 결합 쿼리에 유용합니다
계속해서 데이터를 추가하면서

Indonesian: 
Untuk mengaktifkannya, Anda
harus membuka opsi Prosesor Anotasi
dan juga menyiapkan melalui flag.
Proyeksi perluasan, juga
mengatasi masalah yang berlangsung
lama dari nama kolom yang bertentangan.
Dan Anda dapat
sering melihatnya jika
mencoba menggabungkan
dua tabel yang memiliki
dua kolom dengan nama yang sama.
Misalnya, di sini
ada DogsAndOwners
dan keduanya
memiliki ID nama kolom.
Proyeksi perluasan
mengatasi ini karena Anda
dapat menentukan [...] dan dapat
menggunakan tersematkan dengan awalan.
Dan jika mengombinasikan
awalan dengan operasi SQLite
untuk mengganti nama
tabel, Room akan mencari tahu
kolom mana yang
berisi entitas tertentu
dan Room akan dapat
menulis ulang proyeksi Anda
agar tidak ada
kolom yang bertentangan.
Ini akan memudahkan
kueri dengan join yang besar
yang berisi nama yang bertentangan.
Seiring dengan
penambahan fitur,

Portuguese: 
Enquanto adiciona mais coisas,
você pode manter sua projeção em estrela
e a Room poderá detectar o restante.
Recapitulando, adicionamos 
compatibilidade do Flow na Room.
E conclui a questão das Corrotinas.
você pode ir adiante e usar acoplamento
e Corrotinas em qualquer lugar.
Pode, até mesmo, substituir
dados do Lite pelo Flow.
Consideramos essa uma API melhor,
principalmente porque
a manipulação de erros é
mais adequada.
O banco de dados pré-empacotado
é um recurso
pedido bastante tempo.
Vocês podem ter isso também.
Expandimos as relações, a anotação,
para ter "1 para 1" e
"muitos para muitos"
Se você ainda tem algumas relações
um pouco complicadas,
há sempre a opção de
criar as próprias consultas.
Velocidades de compilação com esse
processador de anotações incremental.
Os corpos padrão de esquema
e as projeções expandidas
também são muito úteis.
Então, vamos testar isso.
Avisem se vocês tiverem
dúvidas ou problemas.
Falem conosco.
Estaremos no sandbox.
Obrigado.
Obrigada
[APLAUSOS]
[MÚSICA TOCANDO]

Indonesian: 
Anda dapat
menyimpan proyeksi bintang,
dan Room akan
tahu semua detailnya.
Untuk meringkas, kami
menambahkan dukungan Flow untuk Room.
Ini melengkapi Coroutine.
Anda dapat menggunakan
penggabungan dan Coroutine di mana saja.
Anda juga dapat
mengganti LiveData dengan Flow,
Kami rasa ini adalah API
yang lebih baik, terutama karena
memiliki penanganan
error yang lebih baik.
Database yang telah
dipaketkan adalah fitur
yang sudah lama diminta.
Ini juga dapat digunakan.
Kami memperluas relasi, anotasi,
untuk memungkinkan
1 banding 1 dan banyak banding banyak.
Jika masih harus
membuat relasi yang rumit,
Anda dapat melakukan
fallback penulisan kueri.
Tersedia kecepatan
build yang tinggi dengan
prosesor anotasi inkremental.
Isi default skema dan
proyeksi yang diperluas
juga sangat berguna.
Silakan mencoba.
Beri tahu kami jika ada
masalah atau kendala apa pun.
Berbincanglah dengan kami.
Kami akan
hadir di sandbox.
Terima kasih.
-Terima kasih.

English: 
can keep your star
projection, and Room will
be able to figure out the rest.
So to recap, we added
Flow support for Room.
That completes the
Coroutine story.
You can go ahead and use
coupling and Coroutines
everywhere.
You can actually also
replace Lite data with Flow.
We feel it's a nicer API,
especially because it
has better error handling.
Pre-packaged
database is a feature
that's been asked for a while.
You can have that, too.
We expanded relations,
the annotation,
to have 1 to 1 and many to many.
If you still have to do some
pretty complicated relations,
there's always the fallback
of writing your own queries.
You get some sweet build
speeds with that incremental
annotation processor.
Schema default bodies
and expanded projections
are also very useful.
So try it out.
Let us know if you have
any issues or problems.
Come talk to us.
We'll be in the sandbox.
Thank you.
FLORINA MUNTENESCU: Thank you.
[APPLAUSE]
[MUSIC PLAYING]

Korean: 
별표 투영을 유지할 수 있습니다
나머지는 Room이 알아서 할 겁니다
요약하자면 Room에
Flow 지원 기능이 추가되어
코루틴을 완성하고
어디서든 결합과 코루틴을
사용하실 수 있습니다
Lite 데이터를 Flow로 대체할 수도 있습니다
더 나은 API라고 생각해요
Flow가 오류 처리에 효율적이기 때문이죠
사전 패키징된 데이터베이스는
오랫동안 요청되어 왔던 기능입니다
이제 사용하실 수 있습니다
관계와 주석을
일대일 및 다대다로 확대했습니다
더욱 복잡한 관계를 처리해야 한다면
쿼리를 직접 작성하는 방법도 있습니다
증분 주석 처리기를 통해
빌드 속도가 향상됩니다
스키마 기본 본문과 확장 투영 또한
매우 유용하죠
한번 사용해 보세요
문제가 있으시면 알려주시기 바랍니다
오셔서 알려주세요
저희는 샌드박스에 있을 겁니다
감사합니다
감사합니다
[박수]
[음악 재생]

Japanese: 
そのまま使えば
後はRoomが
処理してくれます
まとめに入ります
コルーチンを補完する
Flowサポートを追加しました
Kotlinとコルーチンを
どこでも使用できます
LiveDataをFlowに
置換することも可能です
エラー処理が優れているので
より優れた
APIだと思います
要望が多かった
パッケージ済み
データベースも
利用できます
リレーションのアノテーションを
拡張し
１対１と多対多に対応しました
複雑なリレーションの作成が必要なら
代わりに独自のクエリを
いつでも作成できます
インクリメンタルアノテーション
プロセッサーを使えば
ビルド速度が向上します
スキーマ既定値と拡張投影も
非常に便利です
お試しいただき
問題があればお知らせください
こちらでも検証します
ありがとうございました

Chinese: 
能继续使用 * 投影
剩下的事情交给 Room 去解决
总结一下 我们在 Room 中添加了对 Flow 的支持
从而最终完善了协程机制
你可以在任何地方使用耦合和协程
还可以使用 Flow 来替代 Lite 数据
我们认为这个 API 更好用
它在处理错误的时候表现尤其出色
预打包数据库功能是大家期待已久的功能
现在也可用了
我们扩展了 Relations 注解
现在包括一对一和多对多
如果你仍然需要处理较为复杂的关系
那么你随时可以编写自己的查询
增量注解处理器为大家带来了可观的构建速度提升
Schema 默认值和 Expand Projections 也是非常有用的功能
欢迎大家试用 如果遇到问题 欢迎告诉我们
我们就在体验互动区等着大家
谢谢

Spanish: 
podrán encargarse
de su proyección destacada
y Room resolverá lo demás.
Repasemos: agregamos
compatibilidad con Flow en Room
para completar las Corrutinas.
Pueden usar Kotlin
y Corrutinas en cualquier proceso.
También pueden
remplazar datos de Lite con Flow.
Creemos que esta API es mejor,
sobre todo para resolver errores.
Las bases de datos ya preparadas
es una función que pedían mucho.
Ahora ya la tienen.
Ampliamos las relaciones y las anotaciones
para ofrecer 1 a 1 y varios a varios.
Si tienen relaciones aún más complejas,
pueden escribir sus propias consultas.
El procesador de anotaciones incrementales
ofrece gran velocidad de compilación.
También son muy útiles
los cuerpos predeterminados de Schema
y las proyecciones desplegables.
Prueben estas funciones y comuníquense
con nosotros si tienen algún problema.
Estaremos en la zona de pruebas.
-Gracias.
-Gracias.
