
Czech: 
>> Přece přátelé, je další díl Azure pátek.
Jsem zde s Aravind Krishnan
Můžeme se mluví o některé společné
návrhové vzory, které by bylo
najít při práci s
Azure Cosmos DB. Jak jste pane?
>> Dobré. Děkujeme za mě Scott.
>> Moje rekreační. Tak co máte pro mě dnes?
>> Tedy Cosmos DB je skutečně snadné sestavení
škálovatelné aplikace tak můžete data
úložiště a propustnost, růst bez problémů.
Nemusíte se obávat, že schéma.
Nemusíte obávat, že indexování,
to vše, co je dobré.
Tak, mnoho z těchto problémů
jsou stejně jako modely, které vidíme na aplikace patentů.
Tyto mají tendenci umístit několik běžných motivů a patenty.
Tak v této relaci
Chci Procházet.
Možná začíná vanilka případu použití a
Podíváme se na několik výjimek z pravidla.
Ano, chci zdůraznit tyto výjimky pouze pro použití
v případě získání do nebo narazíte na některé druhy problémů.
Tak to být, jak zpracujete zkosí?
Jak zpracovávat zatížení, což je většinou práva.
Ano právě podíváme na jeho případu podle

Russian: 
>> Привет друзья, это другой эпизод Azure пятница.
Я здесь с Aravind Krishnan
мы говорим о некоторых типичных
шаблоны разработки, можно
поиск при работе с
DB Azure Cosmos. Как вы сэр?
>> Хорошие. Спасибо, что пригласили меня Скотт.
>> Мое удовольствие. Так что у вас есть для меня сегодня?
>> Таким образом Cosmos DB делает очень простым создание
масштабируемые приложения, данные можно
расти эффективно с точки зрения хранения и пропускную способность.
Не нужно беспокоиться о схеме.
Не нужно беспокоиться об индексировании,
Поэтому все, что хорошо.
Таким образом, многие из этих проблем
похожи на модели, которые мы видим на патенты приложения.
Они, как правило, в соответствии с несколько общих тем и патенты.
Поэтому в этом сеансе
Просто нужно перебрать.
Вариант использования может быть запуск ваниль и затем
Мы рассмотрим несколько исключений из правила.
Таким образом, требуется нагрузки этих исключений только для использования
в случае получения в или возникли некоторые проблемы.
Поэтому такие операции, как, как обрабатывать наклоны?
Способ обработки рабочей нагрузки, которая является главным образом права.
Таким образом мы просто смотрите на это путем обращения

Chinese: 
>> 嗨朋友，它是 Azure 中的另一個片段星期五。
我在這裡的 Aravind Krishnan
我們說的一些常見
您可能的設計模式
尋找您所使用的
Azure 宇宙 DB。如何是否爵士？
>> 好。謝謝你讓我陳俊銘。
>> 我參與同樂您有什麼關係呢為我今天？
>> 宇宙 DB 所以，讓真的很容易建置
可擴充的應用程式，讓您的資料
順暢地成長，以儲存和輸送量。
您不必擔心結構描述。
您不必擔心編製索引，
因此所有的很好。
因此，許多這些問題
就像我們在應用程式相關的專利看到的模型。
它們通常以符合幾個常見的佈景主題和相關的專利。
在這個課程中，
我只是要逐步解說。
或許香草的開頭使用大小寫，然後，
我們看看一些規則的例外狀況。
因此，我要強調這些只是要使用的例外狀況
萬一您進入或遇到某些類型的問題。
讓一些事，像是，要如何處理時間差異？
您要如何處理工作負載，也就是主要的權限。
因此，我們只看看它的大小寫

German: 
>> Hey Freunde, es ist eine weitere Folge von Azure Freitag.
Ich bin hier mit Aravind Krishnan,
Wir sprechen über einige gängige
Sie können Entwurfsmuster
Wenn Sie arbeiten, suchen
Azure Cosmos DB. Wie sind Sie sir
>> Gut. Danke, dass mir Scott.
>> Gern. So wie ich heute haben Sie?
>> So erleichtert Cosmos DB wirklich erstellen
Skalierbare Anwendung können Daten
Speicher und Durchsatz nahtlos wachsen.
Sie müssen Schema kümmern.
Sie haben nicht die Indizierung sorgen,
Dies alles gute.
So viele dieser Probleme
die Modelle, die wir auf Anwendung Patente sind.
Sie neigen dazu, einige allgemeine Themen und Patenten.
Klicken Sie hierzu in dieser Sitzung
Ich möchte durchlaufen.
Vielleicht starten mit dem Anwendungsfall und
Betrachten wir einige Ausnahmen zur Regel.
Daher möchte ich diese betonen Ausnahmen nur
Wenn Sie in oder in bestimmten Arten von Problemen führen.
Wie behandeln Sie verzerrt, so wie?
Wie handhaben Sie eine Arbeitslast ist meist Rechte.
So betrachten wir nur durch Fall

Polish: 
>> Hej przyjaciele, jest inny odcinek Azure piątek.
Jestem z Aravind Krishnan
mówimy o niektóre typowe
wzorach projektowych, które użytkownik może
Znajdź podczas pracy z
DB kosmos Azure. Jak się masz sir?
>> Dobre. Dziękujemy za zaproszenie Scott.
>> Mam przyjemność. Tak więc co masz dla mnie dzisiaj?
>> Tak DB kosmos sprawia, że naprawdę łatwe do budowania
skalowalnych aplikacji, więc można danych
bezproblemowo wzrastać magazynowania i przepustowość.
Nie musisz się martwić o schematu.
Nie musisz się martwić o indeksowanie,
tak więc wszystko, co jest dobre.
Tak więc, wiele z tych problemów
są podobne do modeli, które widzimy w zakresie patentów aplikacji.
Zazwyczaj mieści kilka typowych motywów i patentów.
Tak więc w tej sesji
Chcę przejść przez.
Może przypadek użycia start z wanilii, potem
Przyjrzyjmy się kilku wyjątki od reguły.
Tak, chcę podkreślić te są wyjątki tylko do korzystania
w przypadku dostać się do lub do niektórych rodzajów problemów.
Takie rzeczy, jak, jak obsługiwać krzywo?
Jak obsługiwać obciążenia, który jest głównie praw.
Tak firma Microsoft wystarczy spojrzeć na sprawy przez to

Spanish: 
>> Hola amigos, es otro episodio de Azure el viernes.
Estoy aquí con Aravind Krishnan,
Estamos hablando de algunos común
modelos de diseño que es posible que
buscar cuando esté trabajando con
DB Cosmos Azure. ¿Cómo estás sir?
>> Buena. Gracias por invitarme Scott.
>> Un placer. Así que ¿qué tienes para mí hoy?
>> Así, Cosmos DB facilita realmente construir
aplicaciones escalables, por lo que los datos pueden
crezca de manera transparente en términos de almacenamiento y rendimiento.
No tiene que preocuparse por esquema.
No tiene que preocuparse acerca de la indización,
por lo que todo lo que es bueno.
Por lo tanto, muchos de estos problemas
son similares a los modelos que vemos en patentes de aplicación.
Tienden a ajustarse a unos temas comunes y patentes.
Por lo que en esta sesión
Sólo desea recorrer.
Tal vez el caso de uso inicio con la vainilla y, a continuación,
nos centramos en algunas excepciones a la regla.
Por lo tanto, quiero enfatizar estas excepciones sólo para utilizar
en caso de ENTRAR o ejecutar en determinados tipos de problemas.
Así que cosas como: ¿cómo maneja sesgos?
¿Cómo se maneja una carga de trabajo que es en su mayor parte de los derechos.
Por lo tanto, sólo miramos lo caso por

Korean: 
>>이 봐 친구는 Azure의 또 다른 에피소드 금요일.
내가 여기와 Aravind Krishnan
몇 가지 일반적인 이야기
디자인 패턴을 수 있습니다
찾기 사용 하 여 작업 하는 경우
Azure Cosmos Db입니다. 어떻게 당신이 요?
>> 좋은. 초대해 Scott입니다.
>> 즐거움입니다. 따라서 갖춰야 할 내 오늘?
>> 따라서 Cosmos DB를 사용 하면 매우 쉽게 작성할 수
데이터 수 있으므로 확장 가능한 응용 프로그램
저장 및 처리량의 관점에서 완벽 하 게 증가 합니다.
스키마에 걱정할 필요가 없습니다.
인덱스에 대해 걱정할 필요가 없습니다.
전부입니다.
따라서 이러한 문제 중 많은
특허 응용 프로그램에서 흔히 볼 수 있는 모델 같습니다.
맞춤 테마와 특허에 대 한 몇 가지 일반적인 경향이 있습니다.
이 세션에서 계산
안내 싶어요.
어쩌면 시작은 바닐라를 사용 하 여 사용 사례를
규칙에 대 한 몇 가지 예외를 살펴봅니다.
이것을 강조 하려는 경우, 예외를 사용 하 여만
경우에서에 또는 특정 종류의 문제를 겪습니다.
같이, 있도록 차이 어떻게 처리 합니까?
대부분 권한 있는 작업을 처리 하는 방법.
따라서 방금 살펴 그 대 여

Chinese: 
>> 您好朋友，它是另一个节目的 Azure 星期五。
我想在这里与 Aravind Krishnan
我们正在讨论一些常用
您可能的设计模式
当您正在使用查找
Azure 宇宙 DB。在哪里先生？
>> 很好。感谢您的邀请我钱。
>> 我今天非常高兴。因此该怎么做我的今天？
>> 因此，宇宙 DB 可以真正轻松地生成
可缩放的应用程序，您的数据能够
在存储和吞吐量方面的无缝增长。
您不必担心如何架构。
您不必担心索引，
因此所有这一切都很好。
因此，这些问题的大量
就像我们看到应用程序项专利为基础的模型。
他们往往以适应几个常见的主题和专利。
因此，在此会话中，
我只是想要遍历。
也许与香草开始用例，然后，
我们看一下规则的一些例外情况。
因此，我要强调这些例外情况，只是为了使用
在种情况下进入，或会遇到某些类型的问题。
所以，像，如何处理歪斜？
您如何处理工作负荷的主要权利。
因此，我们只是看一下通过案例

Japanese: 
>> ね、友人は Azure の別のエピソードです。
私がここで Aravind の Krishnan
いくつかの一般的な話としています。
ことができるデザイン パターン
操作している場合を検索します。
Azure 世界 DB です。Sir にはどのようにしますか。
>> を発揮します。スコット私もありがとうございます。
>> 楽しかったです。何を持っている私の今日ですか。
>>、世界の DB ように本当に簡単に構築
スケーラブルなアプリケーションのデータのことができます。
ストレージとスループットの点でシームレスに拡張します。
スキーマについて心配する必要はありません。
インデックスを作成すると、心配する必要はありません。
すべてをお勧めします。
したがってには、多くのこれらの問題
アプリケーションの特許をで確認するモデルに似ています。
いくつかの一般的なテーマと特許を合わせる傾向があります。
それには、このセッションでは、
だけを解説します。
バニラの開始がケースを使用するかもしれませんし、
ルールにいくつかの例外について説明します。
これらを強調するため、使用する場合のみの例外
場合にまたは、特定の種類の問題が発生します。
したがって、処理方法ずれでしょうか。
権利ではほとんどの場合に作業負荷を処理するには。
ケースに考えてみては、

Turkish: 
>> Merhaba Cuma Azure başka bir bölümünü olduğu, arkadaşların.
Aravind Krishnan ile burada olduğumu,
Sık kullanılan bazı hakkında Başladık
olabilir, tasarım desenleri
ne zaman çalıştığınız bulmak
Azure Cosmos DB. Nasıl sır?
>> İyi. Scott bana sahip için teşekkür ederiz.
>> Benim keyifli. Bu nedenle ne benim için bugün var?
>> Böylece, Cosmos DB gerçekten oluşturmanızı kolaylaştırır
Verilerinizi şekilde ölçeklenebilir uygulamalar
depolama ve verimi açısından sorunsuz bir şekilde büyür.
Şema hakkında endişelenmeniz gerekmez.
Dizin oluşturma hakkında endişelenmeniz gerekmez,
Bu nedenle tüm iyi olan.
Bunu, çok sayıda bu sorunları
Biz uygulama patent üzerinde gördüğünüz modeller gibidir.
Birkaç ortak temalar ve patentleri sığdırmak için eğilimindedir.
Bunu bu oturumda
Sadece izlenecek yol yapmak istiyorum.
Belki kullanım örneği vanilla ile başlar ve sonra
Biz birkaç istisna kural bakın.
Bu nedenle, bu stres istediğiniz sadece kullanmak için özel durumlar
durumda içine almak veya bazı tür sorunları çalıştırın.
Nasıl şeyler istiyor böylece eğriltir ele?
Çoğunlukla hakları olan bir iş yükünü nasıl ele.
Bu nedenle, biz yalnızca bu servis talebi tarafından bakmak

English: 
>> Hey Friends, it's another episode of Azure Friday.
I'm here with Aravind Krishnan,
we're talking about some common
design patterns that you might
find when you're working with
Azure Cosmos DB. How are you sir?
>> Good. Thanks for having me Scott.
>> My pleasure. So what do you have for me today?
>> So, Cosmos DB makes it really easy to build
scalable applications so your data can
grow seamlessly in terms of storage and throughput.
You don't have to worry about schema.
You don't have to worry about indexing,
so all that's good.
So, a lot of these problems
are like the models that we see on application patents.
They tend to fit a few common themes and patents.
So in this session,
I just want to walk through.
Maybe start with the vanilla use case and then,
we look at a few exceptions to the rule.
So, I want to stress these are exceptions only to use
in case you get into or run into certain kinds of issues.
So things like, how do you handle skews?
How do you handle a workload which is mostly rights.
So, we just look at it case by

French: 
>> Bonjour amis, il s’agit d’un autre épisode d’Azure vendredi.
Je suis avec Krishnan de Aravind,
Nous parlons courantes
modèles de conception que vous pouvez
rechercher lorsque vous travaillez avec
Base de données Azure Cosmos. Comment vous les sir ?
>> Bon. Merci de m’avoir Scott.
>> Mon plaisir. Par conséquent, que devez-vous pour moi aujourd'hui ?
>>, Cosmos DB facilite vraiment facile à build
applications évolutives afin que vos données peuvent
Permet d’évoluer en termes de stockage et de débit.
Vous n’avez pas à vous soucier de schéma.
Vous n’avez pas à vous soucier de l’indexation,
Par conséquent, tout ce qui est bon.
Par conséquent, un grand nombre de ces problèmes
sont comme les modèles que nous voir sur les brevets d’application.
Ils ont tendance à quelques thèmes communs et les brevets.
Dans cette session,
Je veux simplement parcourir.
Cas d’usage peut-être démarrer avec la vanille et ensuite,
Examinons quelques exceptions à la règle.
Par conséquent, je veux souligner ces n'exceptions qu’ils utilisent
au cas où vous obtenez dans ou que vous exécutez dans certains types de problèmes.
Afin par exemple, comment gérez-vous les inclinaisons ?
Que faire face à une charge de travail qui est principalement des droits.
Ainsi, nous avons simplement regarder il cas par

Italian: 
>> Hey amici, è un altro episodio di Azure venerdì.
Sono qui con Aravind Krishnan,
Stiamo parlando di alcuni comuni
modelli di progettazione che è possibile
Trova quando si lavora con
Cosmos Azure DB. Come stai sir?
>> Buona. Grazie per avermi Scott.
>> Il piacere. Quindi cosa hai per me oggi?
>> In questo caso, Cosmos DB rende molto semplice la creazione di
applicazioni scalabili, in modo che i dati possono
crescita senza problemi in termini di archiviazione e velocità effettiva.
Non è necessario preoccuparsi di schema.
Non è necessario preoccuparsi di indicizzazione,
in modo che tutto ciò che è buona.
Pertanto, molti di questi problemi
sono come i modelli che vedremo sul brevetti di applicazione.
Tendono a adattare alcuni temi e brevetti comune.
In questa sessione,
Si desidera esaminare.
Forse iniziano con la vaniglia caso di utilizzo e quindi,
verranno esaminate alcune eccezioni alla regola.
In questo caso, desidero sottolineare le eccezioni solo da utilizzare
nel caso in cui si ottiene in o eseguire in determinati tipi di problemi.
In modo che le cose, ad esempio, come si gestiscono inclinazioni?
Come si gestisce un carico di lavoro che per la maggior parte dei diritti.
In questo caso, abbiamo considerazione solo maiuscole da

Portuguese: 
>> Ei amigos, é outro episódio do Azure sexta-feira.
Estou aqui com Krishnan de Aravind
Estamos falando sobre alguns comum
padrões de design que você pode
Localizar quando você estiver trabalhando com
Cosmos Azure DB. Como vai sir?
>> Boa. Obrigado por me Scott.
>> Prazer. Então o que você tem para mim hoje?
>> Assim, o Cosmos DB torna muito fácil criar
aplicativos escalonáveis para que seus dados pode
cresce perfeitamente em termos de armazenamento e taxa de transferência.
Você não precisa se preocupar sobre esquema.
Você não precisa se preocupar sobre a indexação,
Isso tudo o que é bom.
Portanto, muitos desses problemas
são como os modelos que vemos em patentes de aplicativo.
Eles tendem a se ajustar alguns temas comuns e patentes.
Isso nesta sessão
Eu quero percorrer.
Talvez o caso de uso inicial com a baunilha e, em seguida,
Examinaremos algumas exceções à regra.
Então, quero enfatizar essas exceções que usem somente
no caso de você entrar ou executados em determinados tipos de problemas.
Portanto, coisas como, como tratar inclinação?
Como você lida com uma carga de trabalho que é principalmente direitos.
Então, simplesmente examinamos caso por ele

Turkish: 
çalışması ve bunu nasıl görmek için mahkeme aracılığıyla walk.
>> Gibi bir planı seçebilirsiniz.
>> Böylece, izlenecek yol istiyorum.
Bu nedenle GitHub budur.
Ben ortalama, tüm bu örnek her şeyi vardır.
Bunlar çoğunlukla parçaları
Tüm bu desenleri göstermek için.
>> Tamam.
>> Bunu, biz içine atlamak önce.
Sadece özetlemek istiyorum
izleyen hızlı anahtar kavramlar
temel ilkeler, olur
neden benimsemesinde bu desenleri açısından.
>> Tamam.
>> İlk olarak belgeleri olan
Cosmos DB JSON ücretsizdir.
Şema vardı, yalnızca şema olması gerekir demektir
birincil anahtar ve 's
bölüm ve satır anahtar birleşimi.
>> Tamam.
>> İyi. Şimdi belge koleksiyonları içinde kalır.
Bu kapsayıcı ve her biri olan
Bu koleksiyonlar, bölüm anahtar tanımı olmalıdır.
Bu nedenle, bir özelliktir
Veri ölçekleme için kullandığınız olduğunu.
İsteğe bağlı bir dizin oluşturma ilkesine sahip olurlar.
Varsayılan olarak, her şeyi dizinlenir,
Ancak, varsa kapatabilirsiniz
sorgular gitmek istediğiniz istemiyorum.
Otomatik kullanım süresi sonu yoktur.
Bunu, veri serisi zaman aşımına ise,
sona erme windows ayarlayabilirsiniz,

Czech: 
případ a procházet soudu jak přejít přes něj.
>> Vypadá jako plán.
>> Tedy manuální Procházet.
Ano je to GitHub.
I znamená, tyto ukázky jsou všechny ven tam.
Jedná se o převážně fragmenty kódu
pro ilustraci, všechny tyto vzory.
>> V pořádku.
>> Tak, než jsme do něj přejít.
Chci pouze shrnutí
Rychlý klíčové pojmy, které následují,
že se stanou hlavními zásadami
v těchto vzorcích, proč přijmout.
>> V pořádku.
>> První je, že dokumenty v
Cosmos DB jsou prosté JSON.
Pokud bylo schéma je pouze schéma, že měli by mít
primární klíč a že jeho
kombinace oddílu klíč a klíč řádku.
>> V pořádku.
>> Dobré. Nyní v dokumentech zůstat v rámci kolekce.
Jedná se o nádoby a každý z
Definice klíče oddíl musí mít tyto kolekce.
Toto nastavení je vlastnost
použít pro rozšiřování údajů.
Mají zásadu volitelné indexování.
Ve výchozím nastavení vše je indexován,
ale je možné jej vypnout Pokud
nechcete, aby dotazy, které chcete získat.
Je automatické vypršení platnosti.
Takže pokud časového datové řady
můžete nastavit vypršení platnosti systému windows,

Russian: 
случай и пройти суд, чтобы узнать, как пройти через него.
>> Кажется, план.
>> Таким образом давайте обсудим.
Таким образом это на GitHub.
Я имею в виду, все эти примеры являются все существует.
Это в основном фрагментов
для иллюстрации всех этих шаблонов.
>> О ' кей.
>> Таким образом, прежде чем мы заходим его.
Требуется суммировать
Быстрый ключевых концепций, которыми следовать,
руководящие принципы стали
с точки зрения этих шаблонов, почему адаптировать.
>> О ' кей.
>> Сначала — документы, в
Cosmos DB свободны от JSON.
Если у вас есть схема, только схема, что они должны иметь
первичный ключ и, в
Комбинация разделов и ключей строк.
>> О ' кей.
>> Хорошие. Теперь документы остаются в пределах коллекции.
Контейнеры и каждого из
Эти коллекции должны иметь определение ключа секции.
Так, что это свойство
использовать для данных горизонтального масштабирования.
Они имеют политику необязательно индексирования.
По умолчанию все элементы индексируются,
но его можно отключить, если
запросы, которые вы хотите получить не требуется.
Нет автоматического действия.
Поэтому, если превышен ряды данных
можно настроить windows срока действия

Korean: 
사례 및 안내 법원 진행 하는 방법을 볼 수 있습니다.
>> 말 계획입니다.
>> 안내 해 드리죠.
따라서 GitHub에입니다.
내 말은, 모든이 샘플을 몽 땅 잡아 있습니다.
이들은 주로 조각
이러한 패턴의 모든 보여 줍니다.
>> 확인 합니다.
>> 지금 우리가 프로젝트로 이동 하기 전입니다.
요약 하면 싶어요
빠른 주요 개념
없게 된 원칙
이러한 패턴을 채택 하는 이유입니다.
>> 확인 합니다.
>> 첫째는 문서를
JSON에서 DB cosmos가 있습니다.
스키마를 사용한 경우만는
기본 키와의
파티션 키와 행 키 조합입니다.
>> 확인 합니다.
>> 좋은. 이제 문서 컬렉션 내에서 유지 됩니다.
이 컨테이너와 각각의
이러한 컬렉션은 파티션 키 정의 되어 있어야 합니다.
속성, 즉
사용 하는 데이터를 확장 합니다.
선택적 색인 정책을 갖습니다.
기본적으로 모든 인덱스 되 면
하지만 경우 해제할 수 있습니다.
으로 이동 하 여 쿼리를 바람직하지 않습니다.
자동 만료가 있습니다.
따라서 계열 데이터 시간이 있을 경우
만료 windows를 설정할 수 있습니다.

English: 
case and walk through court to see how to go through it.
>> It sounds like a plan.
>> So, let me walk through.
So, this is in GitHub.
I mean, all of these sample are all out there.
These are mostly snippets
to illustrate all of these patterns.
>> Okay.
>> So, before we jump into it.
I just want to summarize
the quick key concepts that follow,
that become the guiding principles
in terms of these patterns, why you adopt them.
>> Okay.
>> First is that documents in
Cosmos DB are free from JSON.
If you had schema, the only schema is they should have
a primary key and that's
a combination of partition key and row key.
>> Okay.
>> Good. Now the documents stay within collections.
These are the containers and each of
these collections must have a partition key definition.
So, that's the property
that you use for scaling out data.
They have an optional indexing policy.
By default, everything is indexed,
but you can turn it off if
you don't want queries you want to go for.
There's automatic expiration.
So, if you have timed series data,
you can set expiration windows,

German: 
Fall und Spaziergang zu sehen, wie es passieren.
>> Klingt wie ein Plan.
>> Lassen Sie mich durchgehen.
Daher ist dies in GitHub.
Ich meine, gibt alle diese Beispiel alle.
Dies sind meist Ausschnitte
Alle diese Muster beschreiben.
>> In Ordnung.
>> Also, bevor wir dorthin springen.
Ich möchte zusammenfassen
die schnelle Schlüsselkonzepte folgen,
die Leitlinien werden
in diesen Mustern, warum sie annehmen.
>> In Ordnung.
>> Zuerst ist in Dokumenten
COSMOS DB sind JSON.
Wäre Schema ist das einzige Schema sollten
Primärschlüssel und des
eine Kombination von Partition und Zeilenschlüssel.
>> In Ordnung.
>> Gut. Jetzt bleiben die Dokumente in Sammlungen.
Dies sind die Container und alle
Diese Sammlungen muss eine Partition Schlüsseldefinition.
Ist die Eigenschaft
für die Skalierung der Daten verwenden.
Sie haben eine optionale Richtlinie indizieren.
Standardmäßig ist alles indiziert,
aber Sie können es bei deaktivieren
Sie möchten nicht Abfragen zu gehen.
Ablauf ist.
Wenn also Daten deren Zeitlimit überschritten ist,
Windows Ablaufdatum kann festlegen

Italian: 
maiuscole e minuscole e Cammina attraverso Corte per informazioni su come risolverlo.
>> Suona come un piano.
>> In questo caso, è possibile scorrere.
Pertanto, è in GitHub.
Intendo dire, in questi esempi sono tutte le presenti.
Si tratta principalmente di frammenti
per illustrare tutti i modelli.
>> OK (Okay).
>> Questa operazione, prima che si passa in esso.
Si desidera riepilogare
i concetti chiave rapidi che seguono,
che diventano i principi
In questi modelli, perché si adotta.
>> OK (Okay).
>> Il primo è che documenti in
COSMOS DB sono esenti da JSON.
Se si dispone dello schema, lo schema solo è che dispongano
una chiave primaria e che del
combinazione di chiave di partizione e riga.
>> OK (Okay).
>> Buona. Ora i documenti rimangono all'interno di insiemi.
Si tratta di contenitori e ogni
Queste raccolte devono essere una definizione di chiave di partizione.
In questo caso, è che la proprietà
utilizzare per il ridimensionamento di dati.
Hanno un criterio di indicizzazione facoltativo.
Per impostazione predefinita, tutto è indicizzato,
ma è possibile disattivarla se
non si desidera che le query che si desidera consultare.
Non c'è scadenza automatica.
Pertanto, se si dispone di tempo serie di dati,
è possibile impostare windows scadenza,

Portuguese: 
caso e passo a passo do tribunal para ver como passar por ele.
>> Parece um plano.
>>, Deixe-me mostre.
Portanto, isso é no GitHub.
Isto é, todos esses exemplos há todo.
Estes são principalmente trechos
para ilustrar todos esses padrões.
>> Okey.
>> Isso, antes de ele entramos.
Quero apenas resumir
os conceitos-chave rápidos que seguem,
que se tornam os princípios de orientação
em termos desses padrões, por que você adotar.
>> Okey.
>> Primeiro é que documentos em
Cosmos DB estão livres de JSON.
Se você tivesse um esquema, o esquema somente é devem ter
uma chave primária e que do
uma combinação de chave de partição e linha.
>> Okey.
>> Boa. Agora os documentos permanecem dentro de coleções.
Estes são os recipientes e cada um dos
Essas coleções devem ter uma definição de chave de partição.
Portanto, que é a propriedade
que você usar para expandir os dados.
Eles possuem uma diretiva opcional de indexação.
Por padrão, tudo é indexado,
mas você pode desativá-la se
Você não quer consultas que você deseja procurar.
Não há validade automática.
Portanto, se atingiram dados de série
Você pode configurar o windows de expiração

Japanese: 
ケースとを通じて、それを経由する方法についての裁判所です。
>> などと言う計画です。
>> ように、順を追って説明しましょう。
、これは、GitHub にします。
つまり、すべてのこれらのサンプルはすべてあります。
スニペットではほとんどの場合は、します。
すべてのこれらのパターンについて説明します。
>> 可能。
>> ためには、それを見る前にします。
だけを集計したいです。
に従って、クイックの主要な概念
指針になること
これらのパターンに関しては、それらを採用する理由です。
>> 可能。
>> 最初に文書化するは、します。
DB の世界では、JSON から無料です。
必要があります唯一のスキーマは、スキーマがある場合
主キーとするの
パーティション キーおよび行キーの組み合わせです。
>> 可能。
>> を発揮します。今すぐ、ドキュメントは、コレクション内に収まります。
これらは、コンテナーとそれぞれ
これらのコレクションには、パーティション キーの定義が必要です。
プロパティは、
データを拡大・縮小に使用することです。
インデックシング ポリシー オプションがあります。
既定では、すべてのインデックスが作成されて、
場合はオフにすることができますが、
移動するクエリを使用しません。
自動有効期限があります。
系列のデータをタイムアウトする場合、
有効期限の windows を設定することができます。

Polish: 
wielkość liter i przejść przez sąd, aby zobaczyć, jak przez to przejść.
>> To brzmi jak plan.
>> Więc Pozwól mi przejść przez.
Tak to w GitHub.
To znaczy, wszystkie te próbki są wszystkie obecnie.
Są to głównie urywki
Aby zilustrować wszystkich tych wzorców.
>> OK.
>> Więc, zanim skok do niego.
Chcę tylko podsumowanie
Szybkie podstawowych pojęć, które należy wykonać,
które stały się zasad przewodnich
pod względem tych wzorców, dlaczego je przyjąć.
>> OK.
>> Po pierwsze to że dokumentów w
Kosmos DB są wolne od JSON.
Gdyby schematu, tylko schemat jest powinny mieć
klucz podstawowy i że 's
Połączenie partycji i klucz wiersza.
>> OK.
>> Dobre. Teraz dokumenty pozostają w kolekcji.
Są to pojemniki i każdego z
Kolekcje te muszą mieć Definicja klucza partycji.
Tak to właściwość
że używasz dla Skalowanie zewnętrzne dane.
Mają one opcjonalne zasady indeksowania.
Domyślnie wszystkie indeksowane,
ale można je wyłączyć, jeśli
nie chcesz kwerend, który chcesz znaleźć.
Ma automatycznego wygaśnięcia.
Tak więc, jeśli upłynął serii danych
można ustawić windows wygaśnięcia

Chinese: 
例，法庭若要了解如何通过它的演练。
>> 这听起来像一个计划。
>>，让我来指导。
因此，这是在 GitHub 中。
我的意思是，所有这些示例都全部存在。
这些都是主要的代码段
为了说明所有这些模式。
>> 好。
>> 因此之前我们跳转到它。
我只是想要概括
按照，快速的关键概念
它成为了指导原则
根据这些模式，采用这些原因。
>> 好。
>> 首先是程序中的文档
DB 宇宙可以自由从 JSON。
如果您拥有架构，唯一架构是它们应具有
为主键字段和它的
分区键和行键的组合。
>> 好。
>> 很好。现在文档保留在集合中。
这些是容器，每个
这些集合必须具有分区键定义。
这就是该属性
对使用扩展数据。
他们有一个可选的索引策略。
默认情况下，所有内容编制索引，
但如果可以将其关闭
您不需要去获得所需的查询。
没有自动过期。
因此，如果有计时系列数据
您可以设置过期时间窗口

French: 
cas et vue d’ensemble de la Cour pour savoir comment résoudre ce problème.
>> Il ressemble un plan.
>>, Laissez-moi guider.
Ainsi, il s’agit de GitHub.
Par exemple, tous ces exemples sont toutes les il.
Il s’agit principalement d’extraits
montrer tous ces modèles.
>> OK.
>> Ce cas, avant de nous lancer dans il.
Je veux simplement synthétiser
les concepts clés rapides qui suivent,
que deviennent les principes directeurs
en termes de ces modèles, pourquoi les adopter.
>> OK.
>> D’abord est que dans les documents
COSMOS DB sont gratuites à partir de JSON.
Si vous aviez schéma, le schéma uniquement est qu’elles doivent avoir
une clé primaire et
une combinaison de clé de partition et de la clé de la ligne.
>> OK.
>> Bon. Désormais, les documents restent dans les collections.
Il s’agit de conteneurs et chacun des
Ces collections doivent avoir une définition de clé de partition.
C’est pourquoi la propriété
que vous utilisez pour faire évoluer les données.
Ils ont une politique d’indexation facultative.
Par défaut, tout ce qui est indexé,
mais vous pouvez le désactiver si
Vous ne voulez pas vous souhaitez aller les requêtes.
Il y a d’expiration automatique.
Par conséquent, si vous avez dépassé le délai série de données,
Vous pouvez configurer windows de l’expiration,

Chinese: 
大小寫，並逐一法院若要觀看如何針對它進行檢查。
>> 聽起來像是一個計劃。
>> 所以，讓我逐步解說。
因此，這是 GitHub。
我的意思，所有這些範例都是全都列出有。
這些是大部分的程式碼片段
為了說明所有的這些模式。
>> [確定]。
>> 的話，我們跳到應在它之前。
我只想合併彙算
遵循，快速的將關鍵概念
它會成為指導原則
根據這些模式中，在您採用的原因。
>> [確定]。
>> 首先是 [的文件中
宇宙 DB 是從 JSON 可用。
如果您有結構描述，是這些方法應該具有唯一的結構描述
主索引鍵，並的
分割索引鍵和資料列的索引鍵的組合。
>> [確定]。
>> 好。現在，文件保持在集合內。
這些是容器和每個
這些集合都必須有資料分割的索引鍵定義。
因此，那就屬性
您對使用相應分攤資料。
它們有選擇性的編製索引原則。
根據預設，所有項目有建立索引，
但您可以將它關閉如果
您不想要尋求的查詢。
沒有自動到期。
因此，如果您已經逾時數列資料
您可以設定到期 windows

Spanish: 
caso y recorra el Tribunal para ver cómo llevar a cabo.
>> Suena como un plan.
>>, Permítanme recorrer.
Por lo tanto, esto está en GitHub.
O sea, todos estos ejemplos son todo allí.
Se trata principalmente de fragmentos
ilustrar todos estos patrones.
>> Está bien.
>> Por lo tanto, antes de saltar en él.
Deseo resumir
los conceptos clave rápidos que siguen,
que se convierten los principios rectores
en cuanto a estos patrones, ¿por qué adoptar.
>> Está bien.
>> En primer lugar es que los documentos en
COSMOS DB estén exentos de JSON.
Si tuviera el esquema, el esquema sólo es deben tener
una clave principal y que de
una combinación de clave de partición y la clave de la fila.
>> Está bien.
>> Buena. Ahora los documentos permanecen dentro de las colecciones.
Estos son los contenedores y cada uno de
Estas colecciones deben tener una definición de clave de partición.
Por lo tanto, es la propiedad
que se utiliza para el escalado de datos.
Tienen una directiva de indexación opcional.
De forma predeterminada, todo el contenido está indexado,
pero usted puede desactivarlo si
no desea que las consultas que desee ir.
No hay caducidad automática.
Por tanto, si se ha superado el tiempo de datos de la serie
Puede configurar windows de caducidad,

German: 
Eindeutigkeits-Integritätsregeln können festgelegt werden.
Und dies ist ein wichtiger Teil
Sammlungen sind über Partitionen skalierte.
Und jede dieser Partitionen
Sie können es als Server vorstellen.
Und Zellbereich Partitionsschlüssel.
Daher wird dies wichtig Wenn
wie man
Ihre Arbeit wird effektiv skalieren.
Im Hinblick auf die Vorgänge
Es ist ein einfacher Satz von grundlegenden primitiven Vorgänge.
So haben Sie die CRUD-Operationen
SAP sind GET, POST, PUT und DELETE.
Sie haben SQL-Abfragen
Dies ist die einzige Partition Abfragen
sowie die Abfrage Cross Partition.
Sie haben einige gespeicherten Prozeduren im Rahmen
eine Partition, die Sie können Dinge tun, wie Massenvorgänge.
Und habe Feed Feed ändern.
Daher ist dies eine Gruppe von Spielzeug.
Und wenn Sie die Grundsätze, die Sie sehen,
Alle diese Muster ist
Wenn Sie von den meisten wechseln
effiziente, am teuersten
Das sind ziemlich geht
Abrufen der sozusagen lesen

Czech: 
můžete nastavit omezení jedinečné klíče.
A to je důležitou součástí
kolekce jsou rozsáhlá mezi oddíly.
A každý z těchto oddílů
To si lze představit jako server.
A je hostitelem rozsah klíče oddílu.
Ano tento parametr se stane důležité při
Přemýšlejte o tom
velikosti pracovní zátěže by účinně rozšiřování.
Nyní, pokud jde o operace,
Jedná se o jednoduchý sadu primitiv základních operací.
Tedy mít operace CRUD
vaše SAP jsou GET, POST, PUT a DELETE.
Tak máte dotazy SQL
To je jediný oddíl pro dotazy
a oddíl křížového dotazu.
Máte některé uložené procedury v rozsahu
oddíl, který umožňuje provádět jako věci hromadné operace.
A krmiv ke čtení a změnit kanál.
Ano toto je sady hraček.
A pokud se podíváte na zásady, které se zobrazí,
všechny tyto vzorky jsou,
Pokud se pokoušíte přejít od většiny
nejnákladnější, efektivní
objednávky jsou poměrně velká přejde
ZÍSKAT, což je ukazatel pro čtení,

Russian: 
можно задать ограничения уникального ключа.
И это является важной частью,
коллекции являются масштабирован на секции.
И каждый из этих разделов
его можно представить как сервер.
И он содержит диапазон ключей раздела.
Таким образом это будет важно при
Подумайте о том, как
Рабочая нагрузка будет масштабировать эффективно.
Теперь в плане операций
Это простой набор примитивов основных операций.
Таким образом у этих операций
в SAP, GET, POST, PUT и DELETE.
Поэтому имеются запросы SQL
Это единственный раздел запросы
а также запрос перекрестного раздела.
У вас есть некоторые хранимые процедуры в рамках
раздел, который позволяет выполнять такие операции, как массовых операций.
И чтение веб-канал и изменить веб-канал.
Таким образом это набор toys.
И если вы посмотрите на эти принципы, которые вы видите,
все эти шаблоны —
Если вы пытаетесь перейти от большинства
эффективный способ самый дорогой,
порядок, практически переход
Получение которого считывается в курсор,

Korean: 
고유 키 제약 조건을 설정할 수 있습니다.
이것은 중요 한 부분이
컬렉션은 조정 아웃 여러 파티션에 있습니다.
이 파티션 중 각
서버로 생각할 수 있습니다.
하 고 다양 한 파티션 키를 호스트 합니다.
따라서,이 것이 중요
방법에 대 한 생각
작업 부하 효과적으로 확장 됩니다.
이제 작업의 관점에서
간단한 집합 연산의 기본 기본형.
CRUD 작업을가지고
SAP 사용자 GET, POST, PUT 및 삭제 됩니다.
따라서 SQL 쿼리를 사용 해야
그건 단일 파티션 쿼리
물론 크로스 파티션 쿼리 합니다.
일부 저장된 프로시저 범위에 있습니다
수 있는 파티션 일 대량 작업을 선택 합니다.
한 피드를 읽고 피드 변경 합니다.
장난감의 집합입니다.
보면 볼 수 있는 원리와
이러한 패턴은,
대부분의 이동 하려는 경우
가장 비싼 효율적
순서는 거의 이동
해당 지점 읽음을 얻을합니다

Turkish: 
benzersiz anahtar kısıtlamaları ayarlayabilirsiniz.
Ve bu önemli bir parçasıdır,
koleksiyonları ölçeklenmiş bölümleri arasında çıkış.
Ve her biri bu bölümler,
Bunu bir sunucu olarak düşünebilirsiniz.
Ve bir dizi bölüm anahtarlarını barındırır.
Bu nedenle, bu zaman önemli olur.
hakkında düşünme
iş yükünüzü etkili bir şekilde ölçek.
Şimdi işlemleri açısından
temel ilkel işlemlerinin basit bir kümesidir.
Bu nedenle, CRUD işlemlerinizi olması
SAP olan GET, POST, PUT ve DELETE.
SQL sorguları, bu nedenle gerekir
tek bir bölüm sorgularınızı olmasıdır.
yanı sıra Çapraz bölümleme sorgu.
Bazı saklı yordamları kapsamında olan
sağlayan bir bölüm toplu işlemleri şeyler istersiniz.
Ve besleme okudum ve besleme değiştirin.
Bu yüzden, kümenizi Toys budur.
Ve gördüğünüz ilkeleri bakarsanız,
Tüm bu desenleri olan,
en gitmek çalışıyorsanız
en pahalı için etkili
sırada olan büyük ölçüde gider
Hangi noktanızı okuma almak,

Spanish: 
puede establecer restricciones de clave única.
Y esto es una parte importante,
las colecciones se escala horizontal en particiones.
Y cada una de estas particiones
se puede considerar como un servidor.
Y ofrece una amplia gama de claves de partición.
Por lo tanto, esto es importante cuando
piense cómo
la carga de trabajo podría escalar eficazmente.
Ahora en términos de operaciones,
es un conjunto simple de primitivas básicas de las operaciones.
Por lo tanto, tiene sus operaciones CRUD
los SAP son GET, POST, PUT y DELETE.
Tienes consultas SQL, por lo que
eso es que las consultas de una única partición
así como la consulta partición cruzada.
Tiene algunos procedimientos almacenados dentro del ámbito de
una partición que le permite hacen cosas como las operaciones masivas.
Y ha leído la fuente y cambiar la fuente.
Por lo tanto, este es el conjunto de juguetes.
Y si observa los principios que se ven,
todos estos patrones es,
Si está intentando ir de más
el más caro, eficaz
la orden son prácticamente va
CONSEGUIR que se lee el punto,

French: 
Vous pouvez définir des contraintes de clé unique.
Et c’est une partie importante,
collections sont mis à l’échelle à la sortie entre les partitions.
Et chacun de ces partitions,
Vous pouvez considérer qu’il en tant que serveur.
Et qu’il héberge une série de clés de la partition.
Par conséquent, cela devient important lorsque
réfléchir à la manière
votre charge de travail serait évoluer efficacement.
Maintenant en termes d’opérations,
Il s’agit d’un ensemble simple de primitives de base des opérations.
Ainsi, vous avez vos opérations CRUD
votre SAP sont GET, POST, PUT et DELETE.
Vous avez des requêtes SQL, donc
C’est à vos requêtes de partition unique
ainsi que la requête croisée de partition.
Vous avez certaines procédures stockées dans le cadre de
une partition qui vous permet d’effectuer notamment les opérations en bloc.
Et vous avez lu des aliments pour animaux et modifiez le flux.
Par conséquent, il s’agit de votre ensemble de jouets.
Et si vous regardez les principes que vous voyez,
tous ces modèles est,
Si vous essayez d’accéder à partir de la plupart
efficace pour la plus coûteuse,
la commande est presque atteint
OBTENIR qui est votre point de lecture,

Portuguese: 
Você pode definir as restrições de chave exclusivas.
E essa é uma parte importante
coleções são scale-out em partições.
E cada uma dessas partições
Você pode pensá-lo como um servidor.
E ele hospeda uma variedade de chaves de partição.
Portanto, isso se torna importante quando
pensar sobre como
sua carga de trabalho seria dimensionar com eficiência.
Agora em termos de operações,
é um conjunto simples de primitivas básicas das operações.
Portanto, você tem as operações CRUD
o SAP são GET, POST, PUT e DELETE.
Você tem consultas SQL, então
é que as consultas de partição única
Assim como a consulta entre partição.
Você tem alguns procedimentos armazenados dentro do escopo
uma partição que permite que você faça coisas como operações em massa.
E você leu feed e alterar o feed.
Portanto, é o conjunto de brinquedos.
E se você examinar os princípios que você vê,
todos esses padrões é,
Se você estiver tentando ir da maioria
eficiente o mais caro
a ordem é praticamente vai
Obtenha o que é o ponto de leitura,

English: 
you can set unique key constraints.
And this is an important part,
collections are scaled-out across partitions.
And each of these partitions,
you can think of it as a server.
And it hosts a range of partition keys.
So, this becomes important when
you think about how
your workload would scale out effectively.
Now in terms of operations,
it's a simple set of basic primitives of operations.
So, you have your CRUD operations
your SAP are GET, POST, PUT and DELETE.
You have SQL queries, so
that's your single partition queries
as well as the cross partition query.
You have some stored procedures within the scope of
a partition that lets you do things like bulk operations.
And you have read feed and change feed.
So, this is your set of toys.
And if you look at the principles that you see,
all of these patterns is,
if you're trying to go from most
efficient to the most expensive,
the order are pretty much goes
GET which is your point read,

Chinese: 
您可以设置唯一键约束。
这是一个重要的组成部分，和
集合是向外扩展跨分区。
和每个这些分区，
您可以将它视为一台服务器。
和它为宿主分区键的范围。
因此，这将成为重要时
思考如何
您的工作负载有效地扩张。
现在的操作，
它是一组简单的操作的基本的基元。
因此，您有 CRUD 操作
自己的 sap 需求的获取、 发布、 传和删除。
因此具有 SQL 查询
这就是您单个分区的查询
以及跨分区的查询。
范围内有一些存储的过程
分区使您可以执行一些操作，例如批量操作。
并且您具有读取源和更改源。
因此，这是您的一套玩具。
如果您看一看，这些原则
所有这些模式是，
如果您正在尝试去从最
效率最高的
该订单是差不多转
获得您的点阅读它，

Italian: 
è possibile impostare vincoli di chiave univoca.
Si tratta di una parte importante,
gli insiemi sono scalabilità orizzontale in partizioni.
E ciascuna di queste partizioni,
può essere considerato di esso come un server.
E che ospita un intervallo di chiavi di partizione.
Pertanto, questo diventa importante quando
si pensa a come
il carico di lavoro dovrebbe scalare in modo efficace.
Ora in termini di operazioni,
si tratta di una serie di primitive di base di operazioni semplici.
In questo caso, si hanno operazioni CRUD
il SAP sono GET, POST, PUT e DELETE.
Si dispone di query SQL, in modo che
che rappresenta la query singola partizione
nonché la query di partizione incrociato.
Si dispongono di alcune stored procedure all'interno dell'ambito
una partizione che consente di eseguire operazioni quali operazioni di massa.
E aver letto i feed e modificare i feed.
Pertanto, questo è il set dei giocattoli.
E se si osserva i principi che vedete,
tutti questi modelli è,
Se si sta tentando di passare dalla maggior parte
efficace per la più onerosa,
l'ordine sono pressoché va
OTTENERE che viene letto il punto,

Polish: 
można ustawić ograniczenia na klucz unikatowy.
I to jest ważnym elementem,
Kolekcje są skalowanej między partycjami.
I każdy z tych partycji
można traktować go jako serwera.
I obsługuje szeroką gamę kluczy partycji.
Tak więc staje się to ważne podczas
Pomyśl o tym, jak
obciążenie sieci może skutecznie skalować.
Teraz pod względem operacji,
jest to prosty zestaw podstawowych podstawowych operacji.
Tak masz swoje operacje CRUD
SAP są GET, POST, PUT i DELETE.
Masz więc zapytań SQL
to jest pojedynczą partycję kwerend
jak również kwerendy krzyżowe partycji.
Masz niektórych procedur przechowywanych w zakresie
partycja, która pozwala robić takie rzeczy operacje zbiorcze.
I po przeczytaniu paszy i zmienić kanał.
Tak to jest Twój zestaw zabawek.
A Jeśli spojrzeć na zasady, które są wyświetlane,
wszystkie z tych wzorców jest
Jeśli próbujesz przejść od większości
efektywne, aby najbardziej kosztowne,
kolejność są prawie elektrotechnicznych blach teksturowanych
GET, który jest odczytywany punktu,

Chinese: 
您可以設定唯一的索引鍵條件約束。
而這是重要的部分，
集合是橫向擴充的所有分割區上。
和每個這些磁碟分割，
您可以將它做為伺服器。
然後，它裝載的磁碟分割的索引鍵範圍。
因此，這個動作非常重要的時機
您考慮如何
您的工作負載會有效地延展。
現在來作業，
它是一組簡單的作業的基本項目。
因此，您可以在此有 CRUD 作業
SAP 是 GET、 張貼、 PUT 及刪除。
您有 SQL 查詢因此
這是單一磁碟分割查詢
以及跨磁碟分割的查詢。
您的範圍內有一些預存程序
可讓您的磁碟分割做一些事，像是大量作業。
然後，您已閱讀摘要並變更摘要。
因此，這是您的玩具集。
如果您看看，原則
所有這些模式的是，
如果您正嘗試從大部分移至
有效率最為昂貴，
順序會幾乎移
取得您的點讀取它，

Japanese: 
一意キー制約を設定することができます。
これは重要な部分、
コレクションは、スケール アウト パーティションにまたがっています。
これらのパーティションでは、
サーバーとしてのことを考えることができます。
ホストしているパーティションのキーの範囲です。
そのため、これが重要になります
方法について考える
ユーザーの作業負荷はスケール アウト効率的にします。
操作で今すぐ
操作の基本的なプリミティブの単純なセットすることをお勧めします。
CRUD 操作があるため、
SAP は、GET、POST、PUT、DELETE です。
したがって、SQL クエリがあります。
1 つのパーティションのクエリ
クロス パーティションのクエリです。
いくつかのストアド プロシージャのスコープ内にある場合
パーティションを使用する一括操作を行うようなものです。
フィードを読み、フィードを変更します。
したがって、これは、おもちゃのセットです。
表示されている原則を確認する場合
これらのパターンは、
ほとんどから移動しようとしている場合
最も高価な効率的です
順序は、ほとんどがです。
ポイントの読み取りを取得します。

Italian: 
la query singola partizione,
la query tra partizioni, quindi,
Infine analisi query di consente di spostarsi su lettura feed.
Oh, interessante. OK, quindi per inserirlo nel contesto di
una persona SQL brain perché un utente SQL precedente.
Query di ricerca, come la scansione di tabella
Se si finisce di dover esaminare
ogni singola riga di rispondere a una domanda,
In questo modo il più costosi
rispetto a un semplice ottenere direttamente,
ID di acquisto o un indice noto.
>> Correggere.
>> Ha un senso.
>> E gli stessi criteri
applicare esattamente come un database relazione.
Inserimento di massa è migliore di POST che è un inserimento,
che è meglio, sostituire
che è leggermente più pesante.
>> OK (Okay).
>> E, infine, se potesse riassumere,
un punto sarebbe che utilizzare feed cambia più.
>> OK (Okay). E forse poteva parlare un
alcune nozioni sull'utilizzo di tale
modificare l'alimentazione e perché è importante.
>> Sì. Pertanto è possibile accedere tramite gli esempi specifici, ma
>> Ideale.
>> Il vantaggio è, si tratta di dati incrementali, destro?
In questo caso, invece di eseguire query su un set di dati di grandi dimensioni,
si sta lavorando fuori i delta e che consente

Chinese: 
您單一磁碟分割的查詢，
您跨磁碟分割的查詢，然後，
最後掃描會查詢移透過讀取的來源。
喔，有趣。好，因此，若要將之放入的內容
SQL 人的大腦，因為我只是舊的 SQL 人。
掃描資料表掃描，類似的查詢，
如果您需要查看，
若要回答問題，每個單一資料列
這樣會比較昂貴
比簡單的直線取得，
購買識別碼或已知的索引。
>> 更正。
>> 這很合理。
>> 和相同的原則
套用一樣關聯資料庫。
大量插入最好也就是 「 插入張貼
最好非取代，
也就是一些額外的重量級。
>> [確定]。
>> 第三，如果我無法彙總，
您應該使用變更餵送，更是一 takeaway。
>> [確定]。或許您可以說話和
該使用相關的一點
變更摘要，以及，為何如此重要。
>> [是]。我可以瀏覽特定的範例，但是，
>> 太棒了。
>> 好處是，它是累加式資料，而右邊？
因此，而不是透過大型資料集，執行查詢
您正在從差異，並可讓

Turkish: 
tek bir bölüm sorgunuzu
Bölüm çapraz sorgunuz ve sonra
son tarama sorgu gider okuma besleme.
OH, ilginç. Bu nedenle, bağlamında koymak için Tamam'ı tıklatın,
SQL kişinin eski bir SQL kişi olduğumu çünkü beyin.
Sorgu, bir tablo taraması gibi tarama
bakmak zorunda sona erdirirseniz
bir soruyu yanıtlamak için her tek satır
Daha pahalı olarak gitme
Basit bir düz get,
Satınalma kodu, veya bilinen bir dizin.
>> Düzeltin.
>>, Bir anlamı yoktur.
>> Ve aynı ilkeleri
yalnızca bir ilişki veritabanı gibi uygulanır.
Toplu ekleme INSERT olan POST iyidir,
Yerine daha iyi olduğu,
biraz daha çok ağır olduğu.
>> Tamam.
>> Ve son olarak, özetlemek,
bir takeaway değişiklik besleme daha kullanmalısınız olurdu.
>> Tamam. Ve belki de konuşurken bir
Bu kullanma hakkında little bit
besleme ve neden önemli olan değiştirin.
>> Evet. Belirli örneklerle olabilmesi ancak,
>> Mükemmel.
>> Faydası artımlı veri, doğru değil mi?
Bu nedenle, büyük bir veri kümesi üzerinde çalışan sorgu yerine,
deltas oturumunu çalışıyorsanız ve izin veren

Czech: 
váš dotaz jeden oddíl
oddíl křížového dotazu a poté,
prohledávání konečně dotaz přechodu přes čtení krmivo.
Pospěšte si zajímavé. V pořádku, tak k umístění, v rámci
osoby SQL mozek, protože jsem na starou osobu SQL.
Dotaz podobný tabulka skenování skenování
Pokud skončíte s prohlédnout
každý jeden řádek odpovědět na dotaz
který bude dražší
než jednoduchý get rovné,
ID dodavatele nebo známý index.
>> Opravte.
>>, Smysl.
>> A stejné zásady
platí stejně jako relace databáze.
Hromadné vložení je lepší než místo, které je vložení,
což je lepší než nahradit,
což je trochu více těžký.
>> V pořádku.
>> A konečně pokud jsem mohl shrnout,
jeden takeaway by změna krmiva by měla používat více.
>> V pořádku. A možná by mohly mluvit
trocha o tomto použití
Změna krmiva a proč je důležité.
>> Ano. Takže můžeme přejít přes konkrétní příklady;
>> Vynikající.
>> Výhodou je, je Přírůstková data vpravo?
Ano, namísto spuštění dotazu ve velké množině dat.
z rozdílů práci, a umožňuje

Chinese: 
您单个分区的查询，
您跨分区的查询，然后，
最后扫描对读取的数据源进行查询转。
哦，有趣。好，因此要将它放在上下文中
一个 SQL 人因为我旧的 SQL 人曾澍。
如表扫描，扫描查询
如果您不得不看看，
每个单个的行来回答问题，
这将会更昂贵
一个简单的比直接得到，
购买 ID 或已知的索引。
>> 更正。
>> 这是可以理解。
>> 和相同的策略
就像关系数据库的应用。
大容量插入优于即插入、 开机自检
最好不是替换
这是有点更多的重量级。
>> 好。
>> 和最后一点，如果我可以总结，
应更多使用更改数据源是一个强项。
>> 好。或许可以说，
一些关于该使用
更改数据源和为什么这一点很重要。
>> 是。因此我可以通过具体的示例但，
>> 很好。
>> 的优点是，它是适当的增量数据？
因此，而不是运行查询对大型数据集，
您正在从增量并允许

English: 
your single partition query,
your cross partition query, and then,
lastly scan query the goes over read feed.
Oh, interesting. Okay, so to put that in the context of
a SQL person's brain because I'm an old SQL person.
Scan query, like a table scan,
if you end up having to look at
every single row to answer a question,
that's going to be more expensive
than a simple straight get,
buy ID, or a known index.
>> Correct.
>> That makes sense.
>> And the same policies
apply just like a relation database.
Bulk Insert is better than POST which is an insert,
which is better than Replace,
which is a little bit more heavyweight.
>> Okay.
>> And lastly, if I could summarize,
one takeaway would be you should use change feed more.
>> Okay. And maybe you could speak a
little bit about that using
change feed and why that's important.
>> Yeah. So I can go through the specific examples but,
>> Great.
>> The benefit is, it's incremental data, right?
So, instead of running query over a large data set,
you're working off of the deltas and that lets

German: 
die Abfrage einzelne partition
die Abfrage Cross Partition und
Schließlich Scan der geht über lesen Feed Abfragen.
Oh, interessant. Okay, also zu, die im Kontext
einer SQL-Person Gehirn bin ich ein altes SQL.
Abfrage, z. B. einen Tabellenscan Scannen
Wenn Sie sich am Ende
jede einzelne Zeile eine Frage
teurer wird
als eine einfache abrufen Sie direkt
Kaufen Sie ID oder einem bekannten Index.
>> Korrigieren.
>> Sinnvoll.
>> Und dieselben Richtlinien
wie eine Beziehung Datenbank anwenden.
Bulk Insert ist besser als POST ist eine Einfügung,
Das ist besser als ersetzen
mehr schwer ist.
>> In Ordnung.
>> Und schließlich, wenn ich also konnte
ein Punkt wäre Änderung Feed mehr verwenden soll.
>> In Ordnung. Und vielleicht Sie ein
wenig zu verwenden
Feed und die Bedeutung zu ändern.
>> Ja. So kann über die Beispiele gehen jedoch
>> Ideal.
>> Der Vorteil ist, inkrementellen Daten richtig?
Also anstatt Abfrage über einer großen Datenmenge,
Arbeiten von Deltas und können

French: 
votre requête de partition unique,
votre requête croisée de partition et ensuite,
Enfin, analyse requête bascule sur lecture aliments.
Oh, intéressant. OK, donc à mettre dans le contexte de
une personne SQL parce que je suis une personne SQL ancienne du cerveau.
Analyser la requête, comme une analyse de table,
Si vous vous retrouvez de devoir regarder
chaque ligne unique pour répondre à une question,
qui se veut plus coûteux
qu’un simple droit obtenir,
ID de fournisseur, ou d’un index connu.
>> À corriger.
>> Qui est logique.
>> Et les mêmes stratégies
appliquer exactement comme une base de données de la relation.
L’insertion en bloc est plus performant que POST, qui est une opération d’insertion,
qui est mieux que de remplacer,
qui est un peu plus lourd.
>> OK.
>> Et enfin, si je pouvais résumer,
un résultat serait que vous devez utiliser des flux de modification plus.
>> OK. Et vous pourriez peut-être parler un
peu sur ce à l’aide de
modifier des aliments pour animaux et pourquoi c’est important.
>> Oui. Donc je peux passer par les exemples spécifiques mais,
>> Idéal.
>> L’avantage est, il s’agit des données incrémentielles, droite ?
Ainsi, au lieu d’exécuter la requête sur un jeu de données volumineux,
vous travaillez sur les deltas et qui vous permet de

Russian: 
запрос одной секции,
запрос перекрестного раздела, а затем
и наконец сканирования запрос переходит на чтение веб-канала.
Кстати интересно. Итак, таким образом, чтобы поместить его в контексте
пользователь SQL мозг, потому что у меня старый человек SQL.
Проверка запроса, как сканирование таблицы
При необходимости просмотрите
Каждая строка один ответ на вопрос
который будет дороже
более простой прямой get,
Купите код или известном индексе.
>> Исправления.
>>, Имеет смысл.
>> И одинаковые политики
применяются как отношение базы данных.
Массовая вставка лучше, чем POST, то есть инструкции insert
что лучше, чем заменить,
что является немного более высокой плотности.
>> О ' кей.
>> И наконец Если я подытожить,
Изменение канала следует использовать более бы один рекламы.
>> О ' кей. И возможно вы говорите
чуть-чуть, использование
Изменение канала и почему это важно.
>> Да. Поэтому можно выполнить конкретные примеры но
>> Отлично.
>> Является преимущество, он представляет добавочные данные?
Таким образом, вместо выполнения запросов через большой набор данных,
Работа с «дельты», которое позволяет

Portuguese: 
a consulta de partição única
consulta entre partição e, em seguida,
Por fim verificação consulta a entrar em leitura feed.
Ah, interessante. Okey, então para colocar que no contexto do
uma pessoa SQL cérebro porque sou uma pessoa antiga do SQL.
Consulta de exame, como uma verificação de tabela
Se você acaba tendo de examinar
cada linha única para responder a uma pergunta
Isso vai ser mais caro
de um simples obter diretamente,
Compre ID ou um índice de conhecidos.
>> Corrigi.
>> Que faz sentido.
>> E as mesmas políticas
aplica como um banco de dados de relação.
Inserção em massa é melhor do que o POST que é uma inserção
qual é o melhor que a substituir,
o que é um pouco mais pesado.
>> Okey.
>> E, por último, se eu poderia resumir,
um argumento seria que você deve usar o feed de alteração mais.
>> Okey. E talvez você pudesse falar um
um pouco sobre o que o uso
Altere o feed e por que é importante.
>> Sim. Para que eu possa através de exemplos específicos,
>> Excelente.
>> A vantagem é que é dados incrementais, certos?
Portanto, em vez de executar consulta um grande conjunto de dados
Você está trabalhando fora os deltas e que permite

Japanese: 
パーティションを 1 つのクエリ
クロス パーティション クエリしてから、
最後にスキャンでは、読み取りフィード経由での移動を照会します。
ああ、興味深いです。さてのコンテキストに配置するために
SQL のユーザーのため、私は以前の SQL ユーザーの脳です。
クエリ、テーブル スキャンをスキャンします。
参照することを終了する場合
1 つの行、質問に回答するには
コストの高いものに
単純な直線を取得、
ID、または既知のインデックスを購入します。
>> を修正します。
>> は理にかなっています。
>> と同じポリシー
関係データベースと同じように適用されます。
一括挿入は、POST は、挿入するよりも
どちらが置き換えるよりよいです。
少し重いことができます。
>> 可能。
>> と、最後に、私が要約すると場合、
変更のフィードを使用する必要がある 1 つのポイントになります。
>> 可能。話すかもしれませんでしたし、
その使用方法を少し
フィードとすることが重要な理由を変更します。
>> はい。特定の例を選択できるようにですが、
>> です。
>> 利点は、インクリメンタル データの右側にあるでしょうか。
、大規模なデータ セットをクエリを実行しているのではなく、したがって、
デルタから作業しているし、することができます。

Korean: 
단일 파티션 쿼리
크로스 파티션 쿼리를
마지막으로 검사 전환 되 읽기 피드 쿼리 합니다.
오, 흥미로운. 지금 하는 컨텍스트에서 확인
SQL 사용자의 이전 SQL 사용자는 내가 머리.
검색 쿼리, 테이블 스캔
확인을 확보 하 게 하는 경우
모든 질문에 대답을 행
그럼 비용이 더 듭니다.
보다는 단순한 직선 get
ID 또는 알려진된 인덱스를 구입 합니다.
>>를 수정 합니다.
>> 하는 것이 좋습니다.
>>와 같은 정책
관계 데이터베이스와 마찬가지로 적용 됩니다.
대량 삽입은 삽입, 게시물 보다 더 좋습니다.
어느 것이 보다 더
더 복잡 합니다.
>> 확인 합니다.
>> 및 마지막으로 요약할 수 있습니까 경우
하나의 가장 변경 피드를 더 사용 해야 될 것입니다.
>> 확인 합니다. 하 고 어쩌면 말할 수 있는
약간 그 사용에 대 한
피드 및 왜 중요 한지를 변경 합니다.
>> 예. 구체적인 예를 통해 설명할 수 있도록 하지만,
>> 유용 합니다.
>> 증분 데이터 오른쪽 혜택은?
따라서 큰 데이터 집합에 대해 쿼리를 실행 하는 대신
델타에서 작업 하 고 수

Polish: 
Kwerenda pojedynczą partycję,
kwerendy krzyżowe partycji, a następnie,
Wreszcie elektrotechniczne blachy teksturowane skanowania kwerendy za pośrednictwem odczytu paszy.
Ach ciekawe. W porządku, tak aby umieścić, że w kontekście
osoba SQL mózgu, ponieważ jestem osobą stare SQL.
Kwerendy skanowania, takie jak skanowanie tabeli,
Jeśli w końcu konieczności Przyjrzyj się
Każdy wiersz w taki sposób, aby odpowiedzieć na pytanie
jest to być droższe
od prostego się proste,
Identyfikator dostawcy lub znane indeks.
>> Poprawne.
>> To ma sens.
>> I tych samych zasad
zastosowanie, podobnie jak relacja bazy danych.
Instrukcja BULK Insert jest lepszy niż POST, który jest insert,
co jest lepsze niż zastąpić,
który jest trochę więcej o dużej gramaturze.
>> OK.
>> I wreszcie Jeśli można podsumować,
jeden Fast byłby paszy zmian należy użyć więcej.
>> OK. A może można mówić
nieco o tym przy użyciu
Zmień źródło i dlaczego to jest ważne.
>> Tak. Więc można przejść konkretne przykłady ale,
>> Wielki.
>> Korzyści, to danych pierwotnych, prawo?
Tak więc, zamiast uruchamiania kwerendy duży zestaw danych,
Podczas pracy z może i pozwala

Spanish: 
la consulta de una única partición,
la consulta partición cruzada y, a continuación,
Por último análisis consultar el producto afectado sobre la fuente de lectura.
Oh, interesante. Está bien, lo coloca en el contexto de
una persona SQL porque soy una persona SQL anterior del cerebro.
Análisis de la consulta, como un recorrido de tabla,
Si tiene que mirar
cada fila única para responder a una pregunta,
que va a ser más caros
que un simple recta obtener,
Id. de compra o una posición de índice determinada.
>> Correcta.
>> Tiene sentido.
>> Y las mismas directivas
aplicar al igual que una base de datos de la relación.
Es mejor que el POST que es una inserción, inserción masiva
que es mejor que reemplazar,
que es un poco más pesado.
>> Está bien.
>> Y, por último, si podría resumir,
para un llevar sería que cambiar fuente debe utilizar más.
>> Está bien. Y quizá podría hablar un
poco acerca del uso de ese
cambiar la fuente y por qué es importante.
>> Sí. Así que puedo ir a través de los ejemplos concretos pero,
>> Grandes.
¿>> La ventaja es que se trata de datos incrementales, derecho?
Por lo tanto, en lugar de ejecutar consultas sobre un conjunto grande de datos,
trabaja fuera de los deltas y que permite

Italian: 
Fai un sacco di lavoro al momento giusto,
in modo che le letture sono economiche.
In questo caso, che diventa molto scalabili
distribuire un tipo di modello.
>> Raffreddare.
>> In questo caso, diamo un'occhiata al caso di utilizzo vaniglia, destra?
In questo caso, è simile al caso di utilizzo più semplice.
In questo caso, ci sono lettori e si supponga,
si sta creando un'applicazione di gioco, e che è stato utilizzato
profili di Windows Media Player e si desidera eseguire la ricerca in base a Windows Media player.
L'implementazione API 31 o GetPlayerById,
AddPlayer o RemovePlayer, UpdatePlayer, vero?
>> Per un lettore singolo e
si sarebbe procede probabilmente interno
l'ambito di tale lettore.
È stato e accedono
chiamare tali query e apprendere che una persona.
>> Correggere.
>> E che deve essere molto veloce, a destra?
>> Quelli che risulterà molto veloce.
E il vantaggio,
Intendo dire, in modo che la nostra classe di Windows Media player, destra?
Nome ID, gestire punteggio, piuttosto una classe semplice.
E il vantaggio,
questo punteggio ogni cosa scritta.
Questa tecnica funzionerà per centinaia di
lettori o miliardi di lettori.
È sufficiente scalare il throughput Cosmos DB.
>> Solo per una maggiore chiarezza,
si è risposto miliardi e sta non assolutamente scherzando.
>> Sì, certamente Sì. Miliardi, intendo dire,

Turkish: 
çok fazla iş doğru zamanda yapın
Böylece okuma ucuzdur.
Bu nedenle, bir çok ölçeklenebilir olur
Dağıtılmış bir desen türü.
>> Serin.
>> Böylece, Vanilla kullanım örneğini, doğru bakalım?
Bu nedenle, basit bir kullanım örneği gibi budur.
Bu nedenle, biz oyuncular varsa ve diyelim ki,
Oyun app oluşturmakta olduğumuz ve kullandıysanız
Player profilleri ve player'ın aramak istiyorsanız.
API 31 gerçekleştir veya GetPlayerById
AddPlayer veya RemovePlayer, UpdatePlayer, sağ?
>> Tümü için tek bir player ve
size büyük olasılıkla içinde yapmaktan
oyuncu kapsamı.
Bunlar oturum ve size kaldı
Bu sorguları arayın ve kişi hakkında bilgi edinin.
>> Düzeltin.
>> Ve doğru çok hızlı olması?
>> Olanlar çok hızlı olacaktır.
Ve güzelliğinin,
Player Sınıfımız, doğru şekilde ben, demek?
Kimlik adı Yüksek Skor işlemek, basit bir sınıfı güzel.
Ve bu güzelliği,
Bu, yazdığınız skoru.
Bunun için yüzlerce çalışır
oyuncu veya oyuncu milyarlarca.
Out, Cosmos DB verimi ölçeklemek yeterlidir.
>> Yalnızca açık olmak,
Söylediğiniz milyarın katı ve değil joking.
>> Evet, emin Evet. Ben milyarın katı, ortalama,

Korean: 
많은 작업이 적절 한 시기에
읽기는 저렴 합니다.
따라서 증가 하 게 됩니다 매우 확장성
패턴의 종류를 분산된 합니다.
>> 세련 된 디자인.
>> 따라서 오른쪽 바닐라 사용 사례를 살펴 보겠습니다.
따라서 가장 간단한 사용 사례에서 처럼입니다.
우리 소속 고 가정해 봅시다
게임 응용 프로그램에 작성 하 고 사용 하 여
플레이어 프로필과 있습니다 플레이어가 조회 하려고 합니다.
31 API 구현 또는 GetPlayerById,
AddPlayer 또는 RemovePlayer, UpdatePlayer, 그래?
>> 모두는 플레이어에 대 한 고
가 할 것 내 것
해당 플레이어의 범위입니다.
로그인을 하 고 있을
이러한 쿼리를 호출 하 고 한 사람이 알아보기.
>>를 수정 합니다.
>> 이며 바로 매우 빠르게 해야?
>>는 매우 빠른 것입니다.
그 아름다움은
내 말은, 바로 플레이어 클래스, 오른쪽?
Id 이름 높은 점수 처리, 아주 간단한 클래스입니다.
이 아름다움은
이 점수가 기록 된 내용을.
이 기능은 나라의 작동
플레이어나 플레이어의 수십억 있습니다.
Cosmos DB 처리량 확장 하기만 하면 됩니다.
>>를 대비해 지우기
수십억을 했다고 하 고 농담 하지는.
>> 예, 확실 예. 수십억, 내 말은,

Spanish: 
hacer un montón de trabajo en el momento adecuado,
para que las lecturas son económicas.
Por lo tanto, se convierte en un método muy escalable
clase distribuida de un patrón.
>> Enfriar.
¿>> Por lo tanto, veamos el caso de uso de vainilla, derecho?
Por lo tanto, es como el caso de uso más sencillo.
Por lo tanto, tenemos los jugadores y digamos,
está creando una aplicación de juegos y ha utilizado
perfiles del Reproductor y desea buscar Reproductor.
La implementación de API 31 o GetPlayerById,
AddPlayer o RemovePlayer, UpdatePlayer, ¿verdad?
>> Todo por un jugador individual y
usted lo haría probablemente dentro
el ámbito de dicho jugador.
¿Inicie sesión y tenía
Llame a las consultas y obtenga información acerca de una persona.
>> Correcta.
¿>> Y que debería ser muy rápido, derecha?
>> Serían muy rápidos.
Y la belleza de la misma,
¿Quiero decir, así que esta es nuestra clase de reproductor adecuado?
Identificación del nombre, controlar la puntuación más alta, bastante clase simple.
Y lo bueno de esto es,
Esto anotó todo lo que escriba.
Esto funcionará para cientos de
reproductores o miles de millones de jugadores.
Necesitará ampliar su rendimiento Cosmos DB.
>> Sólo para ser más precisos,
dice miles de millones y no está bromeando.
>> Sí, seguro que sí. Miles de millones, es decir,

Polish: 
masz sporo pracy w odpowiednim czasie,
tak aby odczyty są niedrogie.
Tak, że staje się bardzo skalowalne
rozdzielone niby wzór.
>> Schłodzić.
>> Tak Przyjrzyjmy się przypadek użycia wanilii, prawo?
Tak to jak Twój najprostszy przypadek użycia.
Tak więc mamy graczy i Powiedzmy,
tworzysz aplikację gier i używano
profile graczy i chcesz wyszukać przez odtwarzacz.
Implementacja interfejsu API 31 lub GetPlayerById,
AddPlayer lub RemovePlayer, UpdatePlayer, PRAWDA?
>> Wszystko dla poszczególnych graczy i
Można to robić prawdopodobnie wewnątrz
zakres tego odtwarzacza.
Czy zalogować i trzeba było
wywołanie tych kwerend i Dowiedz się więcej o tej jednej osoby.
>> Poprawne.
>>, Które powinny być bardzo szybki, prawo?
>> Tych byłoby bardzo szybko.
I piękno to jest,
To znaczy, więc jest to player klasy Nasze, prawo?
Nazwa identyfikatora obsługi najlepszy wynik, dość prostą klasę.
I jest piękno tego,
punktowane to, co piszesz.
To będzie działać w setkach
odtwarzacze lub ogromną liczbę graczy.
Po prostu trzeba skalowania przepustowość kosmos DB.
>> Tak, aby było jasne,
mówi miliardy i nie żartujesz.
>> tak, na pewno tak. Miliardy, to znaczy,

German: 
eine Menge Arbeit rechtzeitig ausführen
Damit Lesevorgänge beansprucht werden.
So wird ein skalierbar
für eine Muster verteilt.
>> Abkühlen lassen.
>> Also Vanille Fall rechts betrachten?
So ist wie die einfachste Anwendungsfall.
Wir haben Spieler und angenommen,
Bauen Sie eine Spiele-app und verwendet haben
Player Profile und Spieler suchen möchten.
31-API implementieren oder GetPlayerById
AddPlayer oder RemovePlayer, UpdatePlayer, nicht wahr?
>> Für Einzelspieler und
Sie würden wahrscheinlich in machen
der Bereich der Spieler.
Möchten sie sich anmelden und Sie
Rufen Sie die Abfragen und erfahren Sie, dass eine Person.
>> Korrigieren.
>> Sollte und nach rechts sehr schnell?
>> Die wäre sehr schnell.
Und die Schönheit,
Ich meine, also unsere Rechte Player-Klasse?
ID Name Bestenliste behandeln, sehr einfache Klasse.
Und die Schönheit,
Diese bewertet, was Sie schreiben.
Dies funktioniert für Hunderte von
Spieler oder Milliarden Beteiligten.
Sie müssen nur den Durchsatz Cosmos DB skalieren.
>> Nur zu löschen
Sie sagte Milliarden und nicht Scherzen.
>> Ja, Ja sicher. Milliarden gemeint,

English: 
you do a lot of work at right time,
so that reads are inexpensive.
So, that becomes a very scalable
distributed kind of a pattern.
>> Cool.
>> So, let's look at Vanilla use case, right?
So, this is like your simplest use case.
So, we have players and let's say,
you're building a gaming app, and you have used
player profiles and you want to look up by player.
The API 31 implement or GetPlayerById,
AddPlayer or RemovePlayer, UpdatePlayer, right?
>> All for an individual player and
you'd be doing it probably within
the scope of that player.
They would log in and you'd
call those queries and learn about that one person.
>> Correct.
>> And that should be very fast, right?
>> Those would be very fast.
And the beauty of it is,
I mean, so this is our player class, right?
Id name, handle high score, pretty simple class.
And the beauty of this is,
this scored whatever you write.
This will work for hundreds of
players or billions of players.
You just need to scale out your Cosmos DB throughput.
>> Just to be clear,
you said billions and you're not joking.
>> Yeah, yeah for sure. Billions, I mean,

Chinese: 
您執行許多工作，在適當的時機
使讀取便宜。
因此，按鈕會變成很容易擴充
分散式的種模式的詳細資訊。
>> 很棒。
>> 因此，我們來看一下香草使用案例中，正確嗎？
因此，這就像是 [簡單的使用情形。
因此，我們，有玩家，讓我們假設，
您正在建立遊戲應用程式中，且使用
玩家設定檔，及您想要查詢的播放程式。
API 31 實作或 GetPlayerById，
AddPlayer 或 RemovePlayer，UpdatePlayer，對吧？
>> 全都是針對個別的播放程式及
您都會這麼做可能會在
該玩家的範圍。
它們會登入，而且您必須
呼叫這些查詢，並深入了解一個以上的人員。
>> 更正。
>>，這應該很快，權限？
>> 那些可能非常快速。
而它的好處是，
我的意思，所以這是我們的播放程式類別，正確嗎？
Id 名稱、 處理最高分，很簡單的類別。
而這樣的好處是，
這計分您撰寫的任何內容。
這將適用於上百個
播放程式或數十億的玩家。
您只需要向外延展宇宙 DB 輸送量。
>> 只是要先釐清，
您所說數十億，您不可以開個玩笑。
>> 是，確定 [是]。數十億，我的意思，

Czech: 
potřebují hodně práce ve správném čase
tak, aby byly levné čtení.
Tak, že bude velmi škálovatelný
distribuované druh vzorku.
>> Vychladnout.
>> Tak Podívejme se na případ použití vanilky, vpravo?
To je tak, jako vaše nejjednodušší případ použití.
Takže jsme hráči a Dejme tomu,
vytváříte aplikace her a použili jste
profily přehrávače a chcete-li vyhledat program Player.
Implementovat rozhraní API 31 nebo GetPlayerById,
AddPlayer nebo RemovePlayer, UpdatePlayer, doprava?
>> Vše pro jednotlivé přehrávače a
jste by být způsobem jej pravděpodobně v rámci
rozsah tohoto přehrávače.
By přihlásit a bylo
volat tyto dotazy a informace o osob.
>> Opravte.
>> A který by měl být velmi rychlé, doprava?
>> Ty by bylo velmi rychlé.
A je výhodou,
I znamená, což je Naše třída player, vpravo?
Název ID zpracování vysoké skóre, velmi jednoduchou třídu.
A je to výhodou,
Toto skóre můžete zapsat.
Toto bude fungovat pro stovky
hráči nebo hráči miliardy.
Potřebujete rozšiřování vašeho Cosmos DB propustnost.
>> Stejně jako jasné,
řekl miliardy a nejsou joking.
>> Ano, Ano, pro jistotu. Miliardy, I rozumí,

Russian: 
сделать много работы в нужное время
Таким образом, чтение недороги.
Таким образом, она становится очень масштабируемым
распределенные вид шаблона.
>> Охлаждения.
>> Таким образом рассмотрим вариант использования ваниль, правом?
Таким образом это похоже на простейший вариант использования.
Таким образом мы игроков и Предположим,
Вы создаете игровые приложения, и были использованы
профили проигрывателя и нужно искать проигрывателем.
Реализуйте интерфейс API 31 или GetPlayerById,
AddPlayer или RemovePlayer, UpdatePlayer, не так ли?
>> Для отдельных проигрывателя и
Вы бы так делали, скорее всего, в
область игрок.
Они бы войти в систему и имеется
вызов этих запросов и узнайте о человек.
>> Исправления.
>> И это очень быстро, право?
>>, Было бы очень быстро.
И красота его,
Я имею в виду, так что это наш класс проигрыватель правой?
Имя кода обработки рекорд, довольно простой класс.
И это Красота,
Это результат, все, что вы пишете.
Это будет работать для сотен
проигрыватели или миллиарды игроков.
Необходимо масштабировать производительность вашего Cosmos DB.
>> Только для ясности,
Вы сказали миллиардов, и не любительский фильм.
>> Да, Да, конечно. Миллиардов, я имею в виду,

Portuguese: 
grande parte do trabalho no momento certo,
para que as leituras são baratas.
Então, que se torna muito dimensionável
tipo distribuído de um padrão.
>> Resfriar.
>> Assim, vamos examinar o caso de uso de baunilha, certo?
Então, é como seu caso de uso mais simples.
Portanto, temos jogadores e digamos,
Você está criando um aplicativo de jogos e você tiver usado
perfis do Player e quiser procurar pelo player.
A implementação de API 31 ou GetPlayerById,
AddPlayer ou RemovePlayer, UpdatePlayer, certo?
>> Tudo para um player individual e
Você poderia fazer isso provavelmente dentro
o escopo pelo player.
Efetuam login e você tinha
chamar essas consultas e saiba mais sobre o que uma pessoa.
>> Corrigi.
>> E que deve ser muito rápidas, certo?
>> Elas seriam muito rápidas.
E a beleza dela,
Isto é, portanto, esta é a nossa classe player, certo?
Nome de identificação, manipular recorde, muito simple classe.
E a beleza dessa,
Isso pontuadas de tudo o que você escreve.
Isso funcionará para centenas de
players ou bilhões de jogadores.
Basta diminuir a taxa de transferência do banco de dados de Cosmos.
>> Apenas para ser honesto,
Você disse bilhões e você não está brincando.
>> Sim, Sim com certeza. Bilhões, isto é,

Chinese: 
做了大量工作，在适当的时间，
这样读都是便宜的。
因此，成为极具伸缩性
分布类型的一种模式。
>> 冷却。
>> 因此，让我们看一下香草用例，右？
因此，这就像是您最简单的使用案例。
因此，我们有玩家，让我们说，
您正在构建一个游戏应用程序，并且使用
播放机配置文件和您想要查找的播放机。
API 31 实现或 GetPlayerById，
AddPlayer 或 RemovePlayer，UpdatePlayer，对吧？
>> 所有的单个玩家和
您将会这样做可能在
那个游戏的范围。
将登录并且已
调用这些查询，了解该人。
>> 更正。
>>，这应该是非常快的权利？
>> 那些会非常快。
和它的优点在于，
我的意思是，这是我们玩家的类，右？
标识名称，处理最高分、 非常简单的类。
好处就是，
这评分您编写的任何内容。
这适用于数百
播放机或数十亿的玩家。
您只需扩张宇宙 DB 吞吐量。
>> 只是为了清楚，
您说过十亿，您不开个玩笑。
>> 是，肯定是。数十亿美元，我的意思是，

Japanese: 
多くの適切なタイミングで作業を行う
できるように、読み取りは高価ではありません。
非常に拡張性が高くなったため、
パターンの種類を配布します。
>> を冷却します。
>> ため、バニラのユース ケース、右を見てみましょうか。
では、最も単純な使用事例と同様です。
では、私たちプレイヤーがあり、たとえば、
使用して、ゲーム アプリケーションでは、作成します。
プレイヤー プロファイルしたい場合、プレイヤーを検索します。
31 の API の実装や GetPlayerById、
AddPlayer または RemovePlayer、UpdatePlayer と思いませんか。
>> の個々 のプレイヤーと
やって内可能性があります。
プレーヤーの範囲です。
ログインすることし、する必要があります。
それらのクエリを呼び出すし、その 1 人のユーザーについて説明します。
>> を修正します。
>> とする必要があります非常に高速で、右ですか。
>> 非常に高速ものになります。
これの長所は、
つまり、ので、これは、player クラスは、右ですか。
Id の名前は、ハイ スコアを処理、非常に単純なクラスです。
これの利点は、
評価を受けたものを記述します。
これは、何百もの動作します。
プレイヤーやプレイヤーの数十億ドルです。
世界のデータベースのスループットを拡張する必要があります。
>> のために、
数十億」として、ない冗談を言っています。
>> はい、確かに [はい] です。つまりな、数十億、

French: 
vous effectuez beaucoup de travail au moment opportun,
afin que les lectures sont peu coûteux.
Par conséquent, qui devient très évolutive
nature distribuée d’un modèle.
>> Refroidir.
>> Alors, examinons le cas d’usage vanille, droit ?
Alors, c’est comme votre cas la plus simple d’utilisation.
Ainsi, nous ont des joueurs et disons,
vous créez une application de jeu, et que vous avez utilisé
profils de lecteur et que vous souhaitez rechercher par le lecteur.
La mise en oeuvre de l’API 31 ou GetPlayerById,
Droit de AddPlayer ou de RemovePlayer, UpdatePlayer ?
>> Pour un joueur et
vous ferait probablement dans
la portée de ce lecteur.
Il doit se connecter et vous aviez
Appelez ces requêtes et obtenir des informations sur les personnes.
>> À corriger.
>> Et qui doit être très rapide, vers la droite ?
>> Celles serait très rapides.
Et de la beauté de ce fait,
Par exemple, donc il s’agit de notre classe de lecteur, droit ?
Nom de l’identification, gérer le score de spam élevé, plutôt une classe simple.
Et de la beauté de ce fait,
ce score de tout ce que vous écrivez.
Cela fonctionnera pour des centaines de
lecteurs ou milliards de lecteurs.
Vous devez simplement faire évoluer votre débit Cosmos DB.
>> Juste pour être clair,
vous avez dit milliards et vous n’êtes pas blague.
>> Oui, Oui sûr. Milliards, par exemple,

Czech: 
Chtěl bych, že jsem mohl jít dále.
Ale I rozumí miliardy je kolik lidí máme.
>> Je známo, že cosmos DB měřítka světového měřítka.
>> Ano, Ano, pro jistotu.
Ano to je nejjednodušším případě, pravá?
Takže Řekněme, že máte k dispozici,
v tomto případě je třeba přijít s klíč oddílu.
A víme, že je všechny klíče přístupu,
takže váš klíč oddílu může být identifikátor.
A to je naprosto v pořádku.
By strongman říci pro většinu oddílů,
Výběr klíče oddílu je Id, protože to je
Nejjednodušší a dává vám
skvělé rozdělení práv mezi oddíly.
Proto získat hladké měřítko out a také přístup ke čtení
Pokud je klíčem pak funguje.
>> A ID, odpusť mé neznalosti
je Id vždy dobré, ale tak
nebo je vždy jedinečný a je vždy
s rostoucími pořadovými čísly?
Je to něco, co se rozhodnete?
>> Si rozhodnout.
A co tato databáze obsahuje, je
id je musí být jedinečný.
Ano, máme omezení v databázi a
kombinace klíč oddílu a jedinečné identifikátory.

English: 
I wish I could go further.
But I mean, billions is how many people we have.
>> Cosmos DB is known to scale the world scale.
>> Yeah, yeah for sure.
So, this is your simplest case, right?
So let's say, you have,
in this case, you need to come up with the partition key.
And we know it's all key based access,
so your partition key could be the Id.
And this is perfectly fine.
I would say the strongman for most of your partitioning,
partition key selection is Id because that's the
simplest and gives you
great distribution of rights across partitions.
So, you get seamless scale out and also read access,
as if it's by key then it works.
>> And is Id, forgive my ignorance,
but is Id always good way
or is it always unique or is it always
an monotonically increasing number?
Is it something you decide?
>> You get to decide.
And what this database provides is
the id is guaranteed to be unique.
So, we have constraints on the database and
the combination of partition key and Ids unique.

Portuguese: 
Eu gostaria que eu poderia ficar ainda mais.
Mas quero dizer, bilhões é quantas pessoas temos.
>> Cosmos DB é conhecido para dimensionar a escala mundial.
>> Sim, Sim com certeza.
Portanto, este é o caso mais simples, certo?
Então, vamos dizer, que tiver,
Nesse caso, você precisa criar a chave da partição.
E sabemos que trata de todas as chaves de acesso com base,
a chave de partição pode ser a identificação.
E isso é perfeitamente aceitável.
Eu diria a strongman para a maioria de particionamento,
seleção de chave de partição é Id porque isso o
mais simples e dá a você
grande distribuição de direitos em partições.
Assim, você obtém escala perfeita e também o acesso de leitura
como se fosse pela chave, ela funciona.
>> E é Id, Perdoe minha ignorância
mas Id sempre boa forma
é sempre exclusivo ou sempre
um número crescente monotônico?
É algo que você decidir?
>> Você precisa decidir.
E o que oferece este banco de dados
a identificação é garantida como sendo exclusivo.
Portanto, temos restrições no banco de dados e
a combinação da chave de partição e identificações exclusivas.

Chinese: 
我真希望我無法繼續執行其他步驟。
但是，我的意思，數十億是我們有很多人。
>> 宇宙 DB 已知縮放世界的小數位數。
>> 是，確定 [是]。
因此，這是最簡單的情況下，正確嗎？
所以讓我們是假設您有，
在此情況下，您需要想動腦筋分割索引鍵。
我們知道它是所有金鑰基礎的存取，
因此您的磁碟分割金鑰可以是 「 識別碼 」。
而這是最適合的。
我認為對於大多數的磁碟分割，strongman
磁碟分割索引鍵是識別碼，因為的
最簡單，並提供您
很好的通訊群組的所有分割區上的權限。
取得不間斷地延展，並讀取存取權，因此，
如同它是由索引鍵再運作。
>> 和 id，原諒我忽略，
但識別碼一定很好的方式
永遠會是它唯一或不
單純地增加的號碼？
它是您所決定的項目嗎？
>> 您可以決定。
此資料庫所提供且
您可以保證的識別碼是唯一的。
因此，我們必須在資料庫上的條件約束和
分割索引鍵和唯一 Id 的組合。

Italian: 
Auguro che avrei potuto procedere.
Ma intendo dire miliardi è il numero di persone abbiamo.
>> Cosmos DB è noto per scalare la scala mondiale.
>> Sì, certamente Sì.
È il caso più semplice, corretto?
Pertanto, di disporre,
In questo caso, è necessario ad avviarsi con la chiave di partizione.
E si sa che tutte le chiavi di accesso base,
in modo che la chiave di partizione può essere l'ID.
E questo è perfettamente normale.
Per la maggior parte di partizionamento, direi di strongman
selezione della chiave di partizione è Id in quanto che la
più semplice e consente
grande distribuzione dei diritti in partizioni.
In questo caso, si ottiene la perfetta scalabilità orizzontale, nonché l'accesso in lettura,
come se fosse dalla chiave quindi funziona.
>> E ID, addebitare il mio ignoranza,
ma è sempre buona Id modo
è sempre univoco o è sempre
un numero crescente?
Si tratta di qualcosa che si decide?
>> È possibile decidere.
E ciò che offre questo database
l'id è sicuramente univoco.
Pertanto, avremo vincoli sul database e
la combinazione di ID univoco e chiave di partizione.

Polish: 
Szkoda, że mogę można przejść dalej.
Ale to znaczy, ile osób mamy jest miliardy.
>> Kosmos DB jest znany do skalowania w skali światowej.
>> tak, na pewno tak.
Tak więc jest najprostszym przypadku PRAWDA?
Powiedzmy, masz,
w takim przypadku należy wymyślić klucz partycji.
I wiemy, że jest cały klucz dostępu na podstawie,
tak więc klucz partycji może być ten identyfikator.
A to jest w porządku.
Chciałbym powiedzieć miejsce dla większości partycjonowania,
wybierania klucza partycji jest identyfikator, ponieważ to
Najprostszy i daje
Doskonały rozkład praw między partycjami.
Tak masz bezszwowe skalowania, a także dostęp do odczytu,
tak, jakby przez klucz to to działa.
>> I jest identyfikator, wybaczyć moją ignorancję
ale Id zawsze jest dobry sposób
jest on zawsze unikatowy lub zawsze jest
monotonicznie rosnący numer?
Czy to coś zdecydujesz?
>> Możesz zdecydować.
I ta baza danych zawiera jest
Identyfikator jest musi być unikatowy.
Tak, mamy ograniczenia w bazie danych i
Kombinacja klucza partycji i unikatowe identyfikatory.

Korean: 
더 이상 채울 수 있을 얼마나 좋을까.
하지만 내 말은, 수십억은 얼마나 많은 사람들이 있다고 합니다.
>> Cosmos DB는 세계 규모의 크기를 조절 하려면 알려져 있습니다.
>> 예, 확실 예.
따라서이 옳다 하면 가장 간단 하 게?
그렇다면 생각해 봅니다,
이 경우 파티션 키를 할 수도 있습니다.
모든 주요 기반된 액세스는 우리가 알 수
따라서 파티션 키 id 수 있습니다.
이것은 완벽 하 고.
분할 대부분의 strongman 말하고 싶습니다.
파티션 키 선택은 하기 때문에 Id를의
가장 간단 하 고 제공
여러 파티션에 권한 훌륭한 배포 합니다.
완벽 한 수평 확장 및 읽기 액세스를 얻을 수
키로 말 이죠 작동 합니다.
>>는 Id와 내 무지 미안 해요
하지만 Id 항상 좋은 방법으로
나는 항상 고유는 항상
일정 하 게 증가 몇 개입니까?
결정 요소는 무엇입니까?
>> 이동 하려면 결정 합니다.
이 데이터베이스에서 제공 하는 것 이며
id는 고유 해야 보장 됩니다.
따라서 데이터베이스에서 제약 조건이 있다고 하 고
파티션 키와 고유 Id의 조합입니다.

Spanish: 
Deseo que podría ir más lejos.
Pero quiero decir, miles de millones es cuántas personas tenemos.
>> Cosmos DB se conoce para escalar la escala mundial.
>> Sí, seguro que sí.
¿Por lo tanto, este es el caso más simple, derecho?
Así que vamos a decir que tiene,
en este caso, debe idear la clave de partición.
Y sabemos que todas las clave acceso basado en,
así que la clave de partición podría ser el Id.
Y esto es correcto.
Yo diría que el hombre fuerte para la mayoría de la partición
selección de clave de partición es Id debido a que el
más sencilla y le da
gran distribución de derechos a través de particiones.
Por lo tanto, obtendrá escalado transparente y también acceso de lectura,
como si es clave, a continuación, funciona.
>> Y es Id, perdonar mi ignorancia
pero Id siempre es buena forma
es siempre único o siempre es
¿un número de progresión?
¿Es algo que decida?
>> Usted puede decidir.
Y es lo que ofrece esta base de datos
se garantiza que el identificador sea único.
Por lo tanto, tenemos las restricciones en la base de datos y
la combinación de clave de partición e identificadores únicos.

French: 
Je souhaite que je peux aller plus loin.
Mais je veux dire, milliards est le nombre de personnes nous ont.
>> Cosmos DB est connue à l’échelle de l’échelle mondiale.
>> Oui, Oui sûr.
Alors, c’est le cas le plus simple, droit ?
Ainsi, par exemple, que vous avez,
Dans ce cas, vous devez trouver la clé de partition.
Et nous savons qu’il est de toutes les touche d ' accès,
votre clé de partition peut être le code.
Et c’est parfaitement normal.
Je dirais que la strongman pour la plupart de votre partitionnement,
sélection de la partition clé est Id car c’est la la
la plus simple et vous permet de
distribution idéale de droits entre les partitions.
Ainsi, vous obtenez sans mise à l’échelle et également l’accès en lecture,
comme s’il s’agit par clé qu’il fonctionne.
>> Et Id, Effacer mon ignorance,
mais Id toujours bonne manière
Il est toujours ou est-il toujours unique
un nombre croissant ?
Il est quelque chose que vous décidez ?
>> Vous obtenez choisir.
Et ce que fournit cette base de données
l’id est garanti unique.
Ainsi, nous avons des contraintes sur la base de données et
la combinaison de la clé de partition et les ID uniques.

Turkish: 
Ben daha ileri gitmek istiyor.
Ancak ben ortalama, milyarın katı olup kaç kişi sahibiz.
>> Cosmos DB dünya ölçeğini ölçekleme bilinmektedir.
>> Evet, emin Evet.
Bu nedenle, bu, en basit durumda, sağ mı?
Bu nedenle, sahip olduğunuz diyelim,
Bu durumda, bölüm anahtarla dönmeniz gerekir.
Ve tüm anahtar tabanlı erişim olduğunu biliyoruz,
Böylece, bölüm anahtar kimliği.
Ve bu mükemmel uygundur.
Bölümleme büyük strongman söylemek,
Bölüm anahtar seçimdir kimliği çünkü o
Basit ve size verir
harika dağıtım haklarının bölümler arasında.
Bu nedenle, sorunsuz ölçeğinizi ve aynı zamanda okuma erişimi almak,
sonra anahtarının ise gibi çalışır.
>> Ve kimliği, benim ignorance affet
ancak kimliği her zaman iyi yolu
her zaman benzersiz olduğundan veya her zaman
düz artan bir sayı?
Bu karar bir şey mi?
>>, Kendiniz karar verirsiniz.
Ve ne bu veritabanı sağlar
kimliği benzersiz olması sağlanır.
Bu nedenle, veritabanı üzerinde kısıtlamalar sahibiz ve
Bölüm anahtarı ve kimlikleri benzersiz birleşimi.

Chinese: 
我希望我可能会更多。
但我的意思是，数十亿是我们有多少人。
>> 宇宙 DB 已知扩展世界规模。
>> 是，肯定是。
因此，这是最简单的情况，正确吗？
因此，让我们说，有，
在这种情况下，您需要提供一些分区键。
我们知道它是所有关键的基于的访问
因此，分区键可能是 id。
这是完全正常。
对于分区过程中，大多数都认为 strongman
分区键选择是 Id，因为那
简单，并可
大跨分区的权限分配。
因此，您可以获得无缝扩展和还读取访问权限
像是由参数然后它工作正常。
>> 和 id，原谅我的无知，
但 Id 总是很好的方式
它始终是唯一或始终是它
单调递增的数字？
正是它决定？
>> 您可以决定。
此数据库提供的了，
保证是唯一的 id。
因此，我们必须在数据库上的约束，
分区键和唯一 Id 的组合。

German: 
Ich wünschte, ich könnte weiter.
Aber Milliarden ist, wie viele Personen haben.
>> Cosmos DB bekanntermaßen die weltweit skalieren.
>> Ja, Ja sicher.
Ist dies der einfachste Fall rechts?
Angenommen, Sie haben,
In diesem Fall müssen Sie den Partitionsschlüssel kommen.
Und wir wissen, dass es alle basiert Zugang
der Partitionsschlüssel konnte die ID sein.
Und das ist perfekt.
Die starken sozusagen für den Großteil der Partitionierung
Auswahl der Partition Id ist, die die
einfachste und
hervorragende Verteilung der Rechte über Partitionen.
So erhalten Sie nahtlose Skalierung und Lesezugriff,
Schlüssel wird dann funktioniert es.
>> Und Id Entschuldige Meine Unkenntnis
aber Id immer gut Weg
Es ist eindeutig oder immer
eine monoton ansteigende Zahl?
Ist Sie entscheiden?
>> Man entscheiden.
Und was diese Datenbank bietet
die Id ist garantiert eindeutig.
Wir haben also Integritätsregeln in der Datenbank und
die Kombination von Partitionsschlüssel und eindeutigen Ids.

Japanese: 
希望に進む可能性があります。
ですが、数十億ドルは、多くの人がいることを意味します。
>> 世界 DB は、世界規模を拡大または縮小するのには知られています。
>> はい、確かに [はい] です。
これは、最も単純なケースでは、右ですか。
したがってがあると、
この例では、パーティションのキーを用意する必要があります。
だと思いますがベースのすべてのキーのアクセス
パーティション キーは id である可能性がありますので
これは完璧です。
パーティション設定のほとんどを strongman と思います
パーティション キーの選択に、Id があるための
最も簡単なを使用して
パーティション間での権限の優れた配布します。
シームレスなスケール アウトとも読み取りのアクセス権を取得するため、
キーである場合と、動作します。
>> Id、および、自分の無知を許すわけには
Id を常に良いですが、方法
一意では、常にまたはそれは、常に
単調に増え続けるでしょうか。
それを決定するものでしょうか。
>> 表示を決定します。
このデータベースが用意されていますが、
id は一意であることが保証します。
データベース上の制約があるためと
パーティション キーと一意な Id の組み合わせです。

Russian: 
Мне бы хотелось может пойти дальше.
Но я имею в виду, миллиардов является того, сколько людей, у нас есть.
>> Масштабирование шкалы мире известен cosmos DB.
>> Да, Да, конечно.
Таким образом это верно в простейшем случае?
Поэтому давайте предположим, у вас есть
в этом случае необходимо придумать ключ раздела.
И мы знаем, что это все ключа на основе доступа
Поэтому ключ раздела может быть идентификатор.
И это совершенно нормально.
Для большинства разделов, скажет strongman
Выбор ключа раздела — идентификатор, так как на
простой и дает
отличный распределение прав между разделами.
Таким образом получить легко масштабировать, а также доступ на чтение
как в случае его ключом затем он работает.
>> И идентификатор, Прости Мои незнанию
но код всегда хорошо способом
он всегда является уникальным или всегда
монотонно возрастающее число?
Это то, что принято решение?
>> Вы получаете решить.
И эта база данных обеспечивает
идентификатор является гарантированно уникальным.
Итак, у нас есть ограничения по базе данных и
сочетание ключа раздела и уникальные идентификаторы.

Russian: 
Но если задать идентификатор ключа раздела
Затем это значение только является уникальным.
>> О ' кей.
>>, В этом случае мы знаем, что это значение только ключа доступа.
Таким образом почему бы не отключить индексирование поскольку, привести к
несколько дополнительных областей обратно в виде индексирования.
Не для это может быть документ
но она безусловно дает
большое влияние при наличии больших документов.
Итак, если взглянуть на получение,
Я имею в виду GetPlayer, это
просто оболочкой вокруг ReadDocumentAsync.
Итак это был нашей первой точки
использовать через запрос GET, поскольку,
известно, что даже не требуется компилировать SQL,
Это просто прямой RSQL.
Добавить игрока, я имею в виду, что можно использовать Upsert, которая подобна
Создатель атомарных в insert или update.
Удаление будет снова удалить.
Теперь для обновления, если взглянуть на шаблон,
Это немного более интересным.
Необходимо сделать условное обновление с ETag.
Таким образом чтение ETag обратно, и вы знаете,
Если это так же, как то, что вы уже ознакомились ранее,
Применить обновления к документу.
И это дает преимущество, не

Portuguese: 
Mas se você definir a Id de chave de partição
em seguida, esse valor só é exclusivo.
>> Okey.
>> Então nesse caso, sabemos que é o valor da mesma chave de acesso.
Então, por que não desativar indexação porque que poderia dar a você
Faça algumas áreas mais em termos de indexação.
Não para talvez este documento,
mas certamente oferece
um grande impacto se você tiver documentos grandes.
Portanto, se você olhar GET,
Quero dizer, GetPlayer, é
apenas um wrapper em torno de ReadDocumentAsync.
Portanto, esse era o nosso primeiro ponto
Use GET consulta porque isto é,
Você sabe que você não precisa compilar SQL, mesmo
é apenas uma RSQL reta.
Adicionar o player, significa que você pode usar Upsert que é como
o criador atômico em insert ou update.
Remover novamente é excluir.
Agora para atualização, se você examinar o padrão
é um pouco mais interessante.
Você precisa fazer uma atualização condicional com uma ETag.
Portanto, leia novamente a ETag e você sabe,
Se for a mesma que você tinha lido anteriormente,
em seguida, aplicar a atualização para o documento.
E isso oferece esse benefício não

Turkish: 
Ancak bölüm anahtarına kimliği ayarlarsanız,
sonra o tek başına benzersiz bir değerdir.
>> Tamam.
>> Bu durumda, yalnızca anahtar değeri erişimi olduğunu biliyoruz.
Size vermek çünkü bu nedenle neden dizin oluşturma devre dışı bırak
yeniden dizin oluşturma açısından daha çok alana birkaç.
Değil Bu belge olabilir için
Ancak, kesinlikle size verir
büyük belgeler varsa, büyük bir etkisi.
Bunu, alma sırasında bakarsanız,
Ben GetPlayer demek, bu
sadece etrafında sarıcı ReadDocumentAsync.
Bu nedenle, bu bizim ilk noktası olduğu,
çünkü sorgu GET kullanın,
bildiğiniz bile SQL derleme gerekmez,
yalnızca düz bir RSQL var.
Player eklemek için ben gibi olan Upsert kullanabilirsiniz anlamına gelir.
INSERT veya update atomik creator.
Kaldır Sil tekrar olur.
Desen bakarsanız şimdi güncelleştirme için
biraz daha ilginç.
Koşullu bir güncelleştirme bir ETag ile yapmak zorunda.
Bunu geri ETag okuyun ve bildiğiniz,
daha önce ne okumak aynı olması durumunda,
belgeye güncelleştirmeyi uyguladıktan sonra.
Ve bu o yararı sağlar.

German: 
Aber wenn Sie Partitionsschlüssel Id festlegen
allein dieser Wert eindeutig ist.
>> In Ordnung.
>> In diesem Fall wissen wir es gerade Wert ist.
So deaktivieren Sie nicht Indizierung da, die könnte Ihnen
einige weitere Bereiche wieder in die Indizierung.
Nicht für dieses Dokument vielleicht
aber es gibt Sie
gravierende Folgen haben große Dokumente.
Also, wenn man erhalten,
Meine GetPlayer,
nur ein Wrapper um ReadDocumentAsync.
Dies war unser Ausgangspunkt,
über Abfrage GET verwenden, da also
Sie wissen, dass Sie noch nicht kompiliert SQL,
Es ist nur eine gerade RSQL.
Spieler, ich meine Upsert verwenden können, wie
der atomare Ersteller einfügen oder aktualisieren.
Entfernen ist wieder löschen.
Für Update, wenn Sie das Muster betrachten,
Es ist etwas interessanter.
Sie müssen eine bedingte Aktualisierung mit einem ETag.
So lesen Sie das ETag zurück, und Sie wissen,
ist dasselbe wie Sie zuvor gelesen haben
dann wenden Sie das Update auf das Dokument.
Und dadurch, dass davon nicht

French: 
Mais si vous la valeur Id clé de partition,
puis cette valeur uniquement est unique.
>> OK.
>> Donc dans ce cas, nous savons que c’est la valeur simplement des accès.
Par conséquent, pourquoi ne pas désactiver l’indexation parce que qui pourrait vous donner
quelques zones plus sauvegarder en termes d’indexation.
Pas de cet exemple de document,
mais elle offre certainement
un grand impact si vous avez des documents volumineux.
Par conséquent, si vous examinez GET,
Je veux dire GetPlayer, il est
un simple wrapper autour de ReadDocumentAsync.
Ainsi, il s’agit de notre premier point,
utiliser GET sur la requête, car,
vous connaissez sans même avoir à compiler SQL,
Il est simplement un RSQL de droite.
Ajouter le lecteur, je veux dire que vous pouvez utiliser Upsert similaire
créateur de l’insertion ou de mise à jour atomique.
Supprimer est à nouveau supprimer.
Maintenant pour la mise à jour, si vous examinez le motif,
Il est un peu plus intéressant.
Vous devez effectuer une mise à jour conditionnelle avec un ETag.
Ainsi, vous lisez l’ETag précédent et vous savez,
Si elle est identique à celui que vous avez lu précédemment,
Ensuite, vous appliquez la mise à jour dans le document.
Et cela vous donne cet avantage de pas

Chinese: 
但如果您設定磁碟分割金鑰識別碼
然後該單獨的值是唯一的。
>> [確定]。
>> 所以在這種情況下，我們會知道它是只是機碼值的存取。
因此，為什麼不關閉索引因為，無法提供您
上一步是用來編製索引的幾個更多領域。
不是針對這文件可能是，
但是它的確提供了
如果您有大的文件的大打折扣。
因此，如果您查看取得，
我是指 GetPlayer，它是
只包裝函式 ReadDocumentAsync。
因此，這是我們的第一個點，
使用 GET 透過查詢，因為也就是
您知道您甚至不必編譯 SQL，
它是只是直線的 RSQL。
將播放程式中，我是指您可以使用了，這就像
在 insert 或 update 不可部分完成的建立者。
移除一次是刪除。
現在來更新，如果您查看模式，
更有趣的是。
您必須執行與 ETag 的條件式更新。
因此，您閱讀 ETag 上一步，而且您也知道，
如果您有在過去，讀取相同
然後將更新套用至文件中。
這可讓您的優點，並不

Chinese: 
但是，如果您将 Id 设置分区键
然后单独的值是唯一的。
>> 好。
>> 因此在这种情况下，我们知道它是只是键的值的访问。
那么，为什么不关闭索引因为它可为您提供
根据索引备份几个更多的领域。
没有为此文档可能，
但它的确为您提供
如果您有大的文档，很大的影响。
因此，如果您看一下 GET，
我的意思是 GetPlayer，它是
只是周围的包装 ReadDocumentAsync。
所以，说这是我们第一个点
因为在查询上使用 GET，即
您知道您甚至不必编译 SQL，
它是只是直的 RSQL。
添加播放机，我的意思是您可以使用 Upsert 就像是
在插入或更新的原子的创建者。
删除再次被删除。
现在对于更新，如果您看一下该模式中，
它是有点更有趣。
您必须执行条件更新使用 ETag。
因此，读回的 ETag，您知道，
如果是以前，您必须阅读相同
然后您将更新应用到文档。
这为您提供了该带来的好处，并不

Polish: 
Ale jeśli ustawisz identyfikator klucza partycji
następnie ta sama wartość jest unikatowa.
>> OK.
>> Więc w tym przypadku wiemy, że jest wartość tylko klucza dostępu.
Tak Dlaczego nie wyłączyć indeksowanie ponieważ mógłby Ci
kilka więcej obszarów z powrotem pod względem indeksowania.
Nie dla może to być dokument
ale to z pewnością daje
duży wpływ, jeśli masz duże dokumenty.
Tak więc, jeśli spojrzeć na GET,
To GetPlayer, to jest
po prostu opakowaniowy ReadDocumentAsync.
Tak jest to nasz pierwszy punkt
Użyj GET ciągu kwerendy, ponieważ oznacza to
wiadomo, że nawet nie trzeba skompilować SQL,
to jest tylko proste RSQL.
Dodać gracza, to znaczy, że używasz Upsert, który jest jak
Twórca Atomowej w insert lub update.
Usuń jest ponownie delete.
Teraz do aktualizacji, jeśli spojrzeć na wzór,
to jest nieco bardziej interesujące.
Co musisz zrobić warunkowe aktualizacji z ETag.
Tak przeczytaj ETag Wstecz i wiesz,
Jeśli jest taka sama jak co czytał wcześniej,
następnie zastosować aktualizację do dokumentu.
I daje korzyści z nie

Korean: 
하지만 파티션 키로 Id를 설정 하는 경우
해당 값은 고유 합니다.
>> 확인 합니다.
>> 지금이 경우는 단지 키 값 액세스 알고 있습니다.
따라서 건 해제 인덱싱 하면 얻을 수 있는
인덱싱의 관점에서 다시 몇 가지 더 많은 지역.
이 문서 볼에
분명 제공 하지만
큰 문서의 경우 큰 영향입니다.
따라서 GET을 보면
내 말은 GetPlayer,
단지 ReadDocumentAsync 주위의 래퍼입니다.
이것이 우리의 첫 번째 포인트
있기 때문에 쿼리에 대해 GET을 사용 하 여,
SQL을 컴파일할 필요도 알으십시오
직선의 RSQL 일 뿐 이며
플레이어를 추가, 내 말은 유사한 Upsert 사용할 수 있습니다.
원자 작성자 삽입 또는 업데이트 합니다.
제거를 다시 삭제 합니다.
이제 패턴을 보면 업데이트에 대 한
그는 좀 더 흥미롭습니다.
ETag 사용 하 여 조건부 업데이트를 수행 해야 합니다.
따라서 ETag를 다시 듣고 있나 하 고 있는데,
앞에서 설명한 것과 동일 하다 면
다음 문서에는 업데이트를 적용합니다.
그 혜택의 제공이 되지

Spanish: 
Pero si establece Id como clave de partición
a continuación, ese valor sólo es único.
>> Está bien.
>> En este caso, sabemos que es el valor de clave sólo acceso.
Por lo tanto, ¿por qué no desactivar la indización debido a podría proporcionarle
algunas áreas más atrás en términos de indización.
No para esto puede documento,
pero que sin duda le da
un gran impacto si tiene documentos grandes.
Por lo tanto, si mira GET,
Me refiero a GetPlayer, es
un contenedor alrededor de ReadDocumentAsync.
Por lo tanto, esto era nuestro primer punto,
utilizar GET sobre consulta porque es decir,
sabrá que ni siquiera es necesario compilar SQL,
es simplemente una recta RSQL.
Agregar Reproductor, es decir que puede utilizar Upsert que es como
el creador atómico en la instrucción insert o update.
Quitar otra vez es delete.
Ahora para la actualización, si observa el patrón,
es un poco más interesante.
Se debe hacer una actualización con un valor ETag condicional.
Por lo tanto, lea el valor ETag atrás y sabe,
Si es el mismo que lo que había leído anteriormente,
a continuación, aplicar la actualización al documento.
Lo que le ofrece beneficios de no

English: 
But if you set Id to partition key,
then that value alone is unique.
>> Okay.
>> So in this case, we know it's just key value access.
So, why not turn indexing off because that could give you
a few more areas back in terms of indexing.
Not for this document maybe,
but it certainly gives you
a big impact if you have big documents.
So, if you look at GET,
I mean GetPlayer, it's
just a wrapper around ReadDocumentAsync.
So, this was our first point,
use GET over query because that is,
you know you don't even have to compile SQL,
it's just a straight RSQL.
Add player, I mean you can use Upsert which is like
the atomic creator in the insert or update.
Remove is again delete.
Now for update, if you look at the pattern,
it's a little bit more interesting.
You have to do a conditional update with an ETag.
So, you read the ETag back and you know,
if it's the same as what you had read previously,
then you apply the update to the document.
And this gives you that benefit of not

Czech: 
Ale pokud nastavíte Id klíč oddílu
samotná hodnota pak je jedinečný.
>> V pořádku.
>>, Takže v tomto případě víme, že je hodnota pouze klíče přístup.
Ano Proč ne vypnout indexování vzhledem k tomu, že by vám
několik více oblastí zpět jako indexování.
Pro tento dokument možná nebude
ale určitě poskytuje
velký dopad, pokud máte velké dokumenty.
Takže pokud se podíváte na GET,
I GetPlayer znamenají, že se
Stačí obal kolem ReadDocumentAsync.
Ano to byl náš první bod
pomocí dotazu použít GET, protože to znamená,
víte, že ještě není nutné kompilovat SQL,
je právě rovné RSQL.
Přidat player, znamenat, můžete použít Upsert, která je podobná
atomovou creator v insert nebo update.
Odebrat je opět odstranit.
Nyní pro aktualizaci, pokud se podíváte na vzorku,
je trochu zajímavější.
Je nutné provést podmíněné aktualizace s ETag.
Takže přečíst ETag zpět a víte,
Pokud je stejný jako co si měl přečíst dříve,
pak nainstalovat aktualizaci dokumentu.
A to vám tato výhoda není

Italian: 
Ma se si imposta l'Id chiave di partizione,
quindi, solo tale valore è univoco.
>> OK (Okay).
>> In modo che in questo caso, si sa che il valore di chiave solo accesso.
In questo caso, perché non disattivare l'indicizzazione poiché che potrebbe fornire
alcune aree più indietro in termini di indicizzazione.
Non per forse questo documento,
ma dà certamente
un grande impatto nel caso di documenti di grandi dimensioni.
Pertanto, se si osserva GET,
Intendo dire, GetPlayer, è
solo un wrapper per ReadDocumentAsync.
Pertanto, questo era il nostro primo punto,
Utilizzare GET su query poiché,
si conosce che ancora non è necessario compilare SQL,
è semplicemente una retta RSQL.
Aggiungere Windows Media player, intendo che utilizzare Upsert analogo a
il creatore atomico insert o update.
Rimuovi nuovamente su delete.
Ora per l'aggiornamento, se si osserva il modello,
è un po' più interessante.
È necessario effettuare un aggiornamento condizionale con un ETag.
In questo caso, leggere l'ETag nuovamente e si conosce,
Se è la stessa cosa fosse letto in precedenza,
quindi necessario applicare l'aggiornamento al documento.
E ciò offre il vantaggio di non

Japanese: 
パーティション キーに Id を設定する場合は
その値を単独では、一意です。
>> 可能。
>> ここで、同じキー値のアクセスがわかっています。
なぜインデックス作成を無効にするを提供するため
いくつかのより多くの領域は、インデックス作成の観点からバックアップします。
文書である可能性ではなく
ですが、確かに
大きなドキュメントがある場合は、大きく影響します。
GET を見る場合、
GetPlayer という、
単なるラッパー ReadDocumentAsync。
最初のポイントが、
クエリに GET を使用して、
では、SQL をコンパイルする必要はありませんが知っています。
直線の RSQL だけです。
プレーヤーを追加、Upsert したようなものを使用するという
insert または update でアトミックの作成者です。
削除は、もう一度削除します。
更新、パターンを確認する場合のようになりました
少し興味深いです。
ETag と条件付き更新を実行する必要があります。
したがって、ETag を戻すを参照してわかっていれば、
以前は、読み取る必要があると同じである場合
ドキュメントに更新プログラムを適用します。
これにより、その利点としません。

English: 
locking the optimized SQL
and currency lets you scale out
effectively for items that infrequently charge.
>> Now, I don't see, and there's no if,
explicitly here it's built within that access condition.
>> Correct. So, you see the access condition is,
if it says if match and that is a request option.
>> And you passing
that condition into this request object,
so it's an implied if you just can't see it.
>> Correct. So, that's your simple vanilla case, right?
So, if you look at it, this
is pretty much the simplest case.
I mean a lot of use cases fit within this bucket.
Now, let's get a little bit more complicated.
What if you have hierarchy?
So, if you have players and players have games.
So, you have one, two, and parent-child relationship
and that's not all that much more complicated as well.
So, in this case,
let's look at our repository class.

Korean: 
최적화 된 SQL 잠금
통화는 확장할 수 있습니다.
효과적으로 자주 충전 항목에 대 한
>> 이제 볼 수 없는, 고가 없는 경우
명시적으로 여기는 내장 되어 해당 액세스 조건 내에서.
>>를 수정 합니다. 액세스 조건이 표시
일치 하 고 있는 요청 옵션 인지 표시 하는 경우.
>>를 전달 하면
이 요청 개체에는 해당 조건
따라서 단순히 보이지 경우는 암시적입니다.
>>를 수정 합니다. 따라서 간단한 바닐라 케이스 맞아 요?
그렇게 보면,이
가장 간단 하 게 잘 됩니다.
이 통에 맞도록 사용 사례를 많이 의미 합니다.
이제 좀 더 복잡 한 해 보겠습니다.
계층이 있을 경우에 어떻게?
따라서 플레이어와 플레이어가 있으면 게임.
따라서이 있는 2 이며 부모-자식 관계
고도 복잡 한 동은 훨씬 더 아닙니다에.
이 경우에 따라서
저장소 클래스를 살펴보겠습니다.

German: 
Optimierte SQL Sperren
und Währung skalieren
für Elemente, die selten belastet.
>> Jetzt nicht angezeigt und gibt keine Wenn
explizit hier es innerhalb dieser zugriffsbedingung basiert.
>> Korrigieren. So finden Sie die Access Zustand
Wenn er sagt Wenn Übereinstimmung und eine Anforderung aus.
>> Und übergeben
die Bedingung in dieser Anforderungsobjekt
So ist eine implizite, wenn Sie nur sehen können.
>> Korrigieren. Deshalb kann der einfachen Vanille Fall rechts?
Wenn Sie betrachtet dies
ziemlich am einfachsten ist.
Meine viel Anwendungsfälle in dieser Rubrik passen.
Nun lassen Sie uns ein wenig komplizierter.
Sie haben Hierarchie?
So haben Sie Spieler und Spiele.
Damit Sie haben zwei und Parent-Child-Beziehung
und, das ist nicht viel komplizierter sowie.
In diesem Fall also
Betrachten wir nun unsere Repository-Klasse.

Spanish: 
bloquear el SQL optimizado
y moneda permite escalar
efectivamente para los artículos que se cargue con poca frecuencia.
>> Ahora, no se ve, y no si no hay
explícitamente aquí se basa en esa condición de acceso.
>> Correcta. Por lo tanto, verá que es de la condición de acceso,
Si dice si coincidencia y que es una opción de la solicitud.
>> Y pasar
esa condición en este objeto de la solicitud,
así que es una implícita si simplemente no puede verla.
>> Correcta. ¿Por lo tanto, es el caso sencillo de vainilla, derecho?
Por lo tanto, si mira, esto
es prácticamente el caso más simple.
Me refiero a muchos casos de uso que quepa dentro de este cubo.
Ahora, vamos a ser un poco más complicado.
¿Qué sucede si tiene jerarquía?
Por lo tanto, si tienes reproductores y tienes juegos.
Para tener uno, dos y la relación de elementos primarios y secundarios
y que no mucho más complicado también.
Por lo tanto, en este caso,
Echemos un vistazo a nuestra clase de repositorio.

Chinese: 
锁定优化的 SQL
货币可以向外扩展
有效地用于不经常收取费用的项目。
>> 现在，我看不到，还有没有如果，
明确在此处构建该访问条件中。
>> 更正。因此，看到访问条件为，
如果它说如果匹配，这是一个请求选项。
>> 和您传递
为此请求对象，该条件
因此，暗示如果您看不到它。
>> 更正。这就是您简单香草的情况下，正确吗？
因此，如果您看一下，这
是非常简单的情况。
我的意思是大量适合此存储桶的用例。
现在，让我们更加复杂。
如果您有层次结构？
因此，如果有玩家和玩家有游戏。
因此，您有一二个和父子关系
然后，不那么得多也复杂。
因此，在这种情况下，
让我们看一下我们存储库中的类。

Portuguese: 
bloqueio de SQL otimizado
e moeda permite dimensionar
eficiência em itens que cobram com pouca frequência.
>> Agora, não vejo e não há nenhum se
explicitamente aqui ele é criado dentro dessa condição de acesso.
>> Corrigi. Então, você vê que é a condição de acesso,
Se ele diz se correspondência e que é uma opção de solicitação.
>> E passando
Essa condição para esse objeto de solicitação
Portanto, é uma implícita se você simplesmente não pode vê-lo.
>> Corrigi. Então, que é o caso simples de baunilha, certo?
Portanto, se você olhar, isso
é muito mais simples caso.
Quero dizer, muitos casos de uso ajustem esse bucket.
Agora, vamos fazer um pouco mais complicado.
Se você tiver hierarquia?
Assim, se você tiver players e players têm jogos.
Portanto, você tem um, dois e relação pai-filho
e que é não muito mais complicado assim.
Portanto, nesse caso,
Vamos examinar nossa classe de repositório.

Italian: 
il blocco di SQL ottimizzata
e valuta consente di ridurre il
in modo efficace gli elementi che raramente addebitare.
>> A questo punto, non viene visualizzato e non esiste, no se
in modo esplicito qui creata all'interno di tale condizione di accesso.
>> Correggere. In questo caso, vedranno la condizione di accesso,
Se indicato se match e che è un'opzione di richiesta.
>> E si passa
tale condizione in questo oggetto di richiesta,
è un implicita se semplicemente non è visibile.
>> Correggere. In questo caso, che è il caso più semplice vaniglia, destra?
Pertanto, se si esamina, in questo
è molto simile al caso più semplice.
Intendo una grande quantità di casi di utilizzo rientrano in questo intervallo.
A questo punto, iniziamo un po' più complicata.
Cosa succede se si dispone di gerarchia?
Pertanto, se si dispone di lettori e sono giochi.
Pertanto, si avrà uno, due e relazione padre-figlio
e che non è molto più complicato anche.
Pertanto, in questo caso,
Esaminiamo la nostra classe repository.

Czech: 
uzamčení optimalizaci SQL
a Měna umožňuje rozšiřování
efektivně pro položky, které zřídka poplatku.
>> Nyní nevidím, a Ne Pokud je
výslovně zde je integrována v rámci této podmínky přístupu.
>> Opravte. Tak vidíte, že je podmínka přístupu,
Pokud se říká, že pokud shoda a že je požadavek na možnost.
>> A předávání
tuto podmínku do tohoto objektu request
je tedy předpokládané Pokud právě není viditelný.
>> Opravte. Toto nastavení je v jednoduchém případě vanilkové pravý?
Takže pokud se podíváte, to
je podstatě nejjednodušší případ.
Znamenat, mnoho případů použití vešel do tohoto bloku.
Nyní můžeme získat trochu složitější.
Co dělat, když máte hierarchie?
Takže pokud máte přehrávači a mít hry.
Tak budete mít jeden, dva a vztah nadřazený podřízený
a který má není všechna tato mnohem složitěji, také.
Ano v tomto případě
Podívejme se na naše třída úložiště.

Japanese: 
最適化された SQL のロック
通貨では、スケール アウトできます。
充電頻度の低いものを効果的に
>> これで、表示されないとがあるない場合、
明示的にここではビルド内でのアクセス条件。
>> を修正します。アクセスの条件は、表示、
一致しているが、要求のオプションがある場合。
>> と受け渡しします。
この要求オブジェクトには、その条件
これは、黙示的なだけで表示されない場合です。
>> を修正します。単純なバニラはそうでは、右ですか。
ですから、見ても、この
非常に単純なケースです。
このバケット内に収まるような用途の多くを意味するとします。
ここで、少し複雑を取得します。
階層がある場合ですか。
ある場合のプレイヤーとプレイヤーはゲームをしてください。
1 つがあるため、2、および親と子の関係
ないそれはより複雑にもできます。
ここでは、
リポジトリ クラスを見てみましょう。

Russian: 
Блокировка оптимизированного SQL
и валюте позволяет масштабировать
эффективно для номенклатур, которые редко издержки.
>> Теперь нет, и нет никаких Если
явно здесь он встроен в условия доступа.
>> Исправления. Таким образом вы видите, что условия доступа
Если там написано, если совпадение и является параметром запроса.
>> И передачи
Это условие в этот объект запроса
так что это подразумеваемых если его просто не видно.
>> Исправления. Таким образом верно в простой случай соответствующего ванили?
Итак, если взглянуть на него, это
Это во многом простейшем случае.
Я имею в виду много вариантов использования в этом сегменте.
Теперь давайте немного сложнее.
Что делать, если у вас есть иерархия?
Таким образом при наличии игроков и игроков имеют игры.
Таким образом, у вас есть один, два и отношения подчинения
а также, не все, что гораздо более сложен.
Таким образом в данном случае
Давайте взглянем на наш класс репозитория.

Turkish: 
en iyi duruma getirilmiş SQL kilitleme
ve para birimi, Ölçek sağlar
seyrek ücretinin etkili maddeler için.
>> Şimdi, görmüyorum ve eğer hiç yok,
açıkça burada, bu erişim koşul içinde yerleşik olarak bulunur.
>> Düzeltin. Bu nedenle, erişim koşul olup,
eşleşme ve istek seçeneği olup olmadığını diyorsa.
>> Ve geçirme
Bu koşulun içine bu request nesnesi
Bu nedenle yalnızca onu göremiyorsanız, örtük bir olur.
>> Düzeltin. Bu nedenle, basit vanilla durumda, sağ mı?
Bunu, onu bakarsanız bu
oldukça çok basit bir durumdur.
Ben çok bu sepet içinde uygun kullanım örneklerinin anlamına gelir.
Şimdi, diyelim ki biraz daha karmaşık alın.
Hiyerarşi yoksa ne?
Bu nedenle, varsa Oyuncular ve oyuncu oyun gerekir.
Biri olması için iki ve üst-alt ilişkisi
ve, daha çok şey değil de karmaşık.
Bu nedenle, bu durumda
Havuz Sınıfımız bakalım.

Chinese: 
鎖定最佳化的 SQL
和貨幣可讓您向外擴充
有效地用於不常收費的項目。
>> 現在，我看不到，並沒有任何假設，
明確這裡它已內建內存取條件。
>> 更正。因此，您可以看到存取條件為，
如果顯示 [供應商比對，而且如果是要求選項。
>>，而您傳遞
為此要求的物件，該條件
所以，隱含如果您只是看不見它。
>> 更正。因此，那就簡單的開啟了香草案例，正確嗎？
因此，如果您看看，這
是差不多就是最簡單的情形。
我是指大量符合這個桶的使用案例。
現在，我們要讓有點複雜。
如果您有階層？
因此，如果您有玩家和玩家有遊戲。
因此，您也可以有一個、 二和父子式關聯性
然後，已不那麼更複雜也。
因此，在此情況下，
讓我們來看我們的儲存機制類別。

Polish: 
blokowanie zoptymalizowany SQL
i Waluta umożliwia skalowanie
skutecznie dla elementów, które rzadko ładowania.
>> Teraz nie jest widoczny, i nie ma żadnych if
jawnie tutaj jest zbudowany w ramach tego warunku dostępu.
>> Poprawne. Tak widać, że jest warunek dostępu,
Jeśli twierdzi, że jeśli mecz oraz że jest opcja.
>> I przechodzenia
Ten warunek do tego obiektu request
tak to wprost jeśli tylko jest on niewidoczny.
>> Poprawne. Tak więc to prostym przypadku wanilii, PRAWDA?
Tak więc, jeśli spojrzeć na to, to
jest prawie w najprostszym przypadku.
To znaczy dużo przypadków użycia mieszczą się to Wiadro z farbą.
Teraz przejdźmy trochę bardziej skomplikowane.
Co zrobić, jeśli masz hierarchii?
Tak więc jeśli masz odtwarzaczami i mają gry.
Tak, masz jeden, dwa, a relacja typu nadrzędny podrzędny
i że nie wszystko, co znacznie bardziej skomplikowane, jak również.
Tak w tym przypadku,
Przyjrzyjmy się klasy nasze repozytorium.

French: 
verrouillage du SQL optimisé
et devise vous permet de faire évoluer
efficacement des éléments de peu de frais.
>> Maintenant, je ne vois pas, et il n’y a aucun cas,
ici il est généré de façon explicite dans cette condition d’accès.
>> À corriger. Ainsi, vous voyez que la condition d’accès est,
Si elle indique si la correspondance et qui est une option de requête.
>> Et que vous en passant
Cette condition dans cet objet de la demande,
Il est donc un implicite si vous simplement ne pas le voir.
>> À corriger. C’est votre cas vanille simple, droit ?
Par conséquent, si vous la regardez, cela
est à peu près le cas le plus simple.
J’entends un grand nombre de cas d’utilisation au sein de cette plage.
Maintenant, nous allons apprendre un peu plus compliqué.
Que se passe-t-il si vous avez hiérarchie ?
Ainsi, si vous disposez de lecteurs et avoir les jeux.
Ainsi, vous en avez un, deux et relation parent-enfant
et qui n’est pas que beaucoup plus compliqué ainsi.
Par conséquent, dans ce cas,
Examinons notre classe de référentiel.

Chinese: 
它是透過相同的資料集。
但我做什麼，我會設定播放程式識別碼為我的磁碟分割索引鍵。
然後，也就是說，我可以取得所有播放程式的資料。
因此，如果我想要實作的 GetGameAsync，
然後我只是傳入我的播放程式識別碼] 及 [遊戲的識別碼
而且同樣的我可以在其中執行 GET。
然後同樣地，如果我想要尋找
所有玩家的遊戲。
我知道這是為例，
連結查詢時，我看到播放程式識別碼等於播放程式識別碼。
因此，這是一次延長查詢
傳送給後端和它的
仍然只限於單一磁碟分割的索引鍵。
因此，還有效率。
所以，那個不那麼更複雜，權限？
因此，如果您有 1:N，
索引鍵是如果您有該階層中，
您想要的父代
階層架構讓您分割索引鍵。
而且此處同樣地，我們堅持只用單一磁碟分割的查詢
以及其他原始物件中，按一下 [觀眾基本型別。
因此這是很好的縮放。
現在，讓我們先進入例外狀況。

Czech: 
Je přes stejnou sadu dat.
Ale co dělat, mám nastaveno id přehrávače jako můj klíč oddílu.
A to znamená, můžete jej získat všechna data pro přehrávač.
Tak jsem chtěla implementovat GetGameAsync,
pak I stačí pouze předat můj přehrávač Id a game Id
a pak znovu provést GET.
A podobně Pokud chcete najít
všechny hry s přehrávačem.
Vím, že je to například
odkaz dotazu, kde vidět, že přehrávač Id odpovídá ID přehrávače
Ano toto je opět sequel dotaz
Odeslaná back-end a jeho
stále s rozsahem klíč jeden oddíl.
Tak to je také efektivní.
Tak, že to ne mnohem složitěji, doprava?
Takže pokud máte 1: n,
Pokud máte hierarchii, je klíč
Chcete-li využít rodičem
hierarchie usnadnit váš klíč oddílu.
A zde opět můžeme přilepit na jednom oddílu dotazy
stejně jako primitiv zbývající DAV primitiv.
Tak to bude skutečně škálovatelné.
Nyní můžeme získat do výjimek.

Polish: 
Jest przez ten sam zestaw danych.
Ale co robię, jest ustawić identyfikator odtwarzacza jako mój klucz partycji.
A to oznacza, można uzyskać wszystkie dane dla odtwarzacza.
Tak więc, jeśli chciałem, aby zaimplementować GetGameAsync,
następnie można po prostu przekazać w moim odtwarzaczem identyfikator i identyfikator gier
a następnie ponownie, można zrobić GET.
I podobnie jeśli chcesz znaleźć
wszystkie gry gracz.
Wiem, że jest to na przykład
kwerendy łącza, gdzie zobaczyć player Id równa player identyfikatora.
To ponownie kwerendę sequel
to jest wysyłane do back-end i jego
nadal objęty zakresem klucz jednej partycji.
To jest również skuteczne.
Tak nie było jednym znacznie bardziej skomplikowane, prawo?
Tak więc, jeśli masz 1: n,
klucz jest, jeśli masz tej hierarchii
chcesz podjąć element nadrzędny
Hierarchia sprawiają, że Twój klucz partycji.
I w tym miejscu ponownie, trzymać się jednej partycji kwerendy
a także prymitywów reszta prymitywów tłum.
To będzie tak naprawdę dobrze skalowalne.
Teraz przejdźmy do wyjątków.

English: 
It's over the same data set.
But what I do, is I set player id as my partition key.
And this means, I can get all of the data for player.
So, if I wanted to implement a GetGameAsync,
then I just pass in my player Id and game Id,
and then again, I can do a GET.
And similarly, if I want to find
all of the games of a player.
I know that this is for example,
a link query, where I see player Id equals player Id.
So, this is again a sequel query
that's sent to the back-end and it's
still scoped to a single partition key.
So that's also efficient.
So, that one was not that much more complicated, right?
So, if you have 1:N,
the key is if you have that hierarchy,
you want to take the parent of
the hierarchy make it your partition key.
And here again, we stick to single partition queries
as well as the rest primitives, the crowd primitives.
So this is going to scale really well.
Now, let's get into the exceptions.

Italian: 
Esso è lo stesso set di dati.
Ma cosa, è possibile impostare id Windows Media player come la chiave di partizione.
E ciò significa che, per ottenere che tutti i dati per Windows Media player.
Pertanto, se si desidera implementare un GetGameAsync,
quindi basta passare il mio lettore Id e giochi,
e quindi nuovamente, posso GET.
E, analogamente, se si desidera cercare
tutti i giochi di un lettore.
So che si tratta, ad esempio,
una query di collegamento, dove vedo player Id uguale a Windows Media player ID.
È nuovamente una query sequel
che viene inviato al server back-end e le relative
ancora l'ambito di una chiave singola partizione.
Questa è efficiente.
Pertanto, che uno non stato che è molto più complicato, a destra?
Pertanto, se si dispone di 1: n,
la chiave è la presenza di tale gerarchia,
si desidera utilizzare l'elemento padre di
la gerarchia renderla la chiave di partizione.
E qui, abbiamo attaccato alle query singola partizione
Oltre alle primitive resto, le primitive di folla.
Questo modo, verranno in scala molto efficiente.
A questo punto, iniziamo in eccezioni.

Chinese: 
它是对相同的数据集。
但我做什么，我设置播放机 id 作为我的分区键。
这意味着，我可以得到所有播放机的数据。
因此，如果我想要实现 GetGameAsync
我只是将我的播放机中 Id 和游戏 Id，
然后我再说一遍，执行 GET 操作。
与此类似，如果我想要查找
所有玩家的游戏。
我知道这是例如，
链接查询，看玩家 Id 等于玩家 id。
因此，这再次是后续查询
发送到后端，
仍仅限于单个分区键。
因此，也是有效的。
因此，那个不是更加复杂，对吗？
因此，如果您具有 1: n
关键是如果您有该层次结构
您要从中取走的父级
层次结构使分区键。
和这里再次强调，我们坚持使用单个分区的查询
以及其他基元，人群基元。
因此这将很好地扩展。
现在，让我们进入异常。

Japanese: 
同じデータ セットです。
ですが、何かは、設定のプレーヤー id、パーティション キーとして。
つまり、すべてのプレイヤーのデータが表示されることができます。
GetGameAsync を実装したい場合、
だけを渡して、プレーヤー Id とゲーム Id は、
再度、取得を行うことができます。
同様に、確認したい場合
すべてのプレイヤーのゲームです。
これはたとえば、
プレイヤー Id に等しいプレイヤー id。 表示、リンク クエリ
これは、もう一度結果クエリです。
バックエンドと送信します。
まだ 1 つのパーティション キーのスコープです。
これは効率的なまた。
その 1 つでしたがかなり複雑ですが、右ですか。
1: n がある場合、
キーは、その階層構造があるかどうか
親を取得します。
階層を使用すれば、パーティション キーです。
クエリの 1 つのパーティションにだけもう一度、ここで
残りプリミティブでは、群衆のプリミティブです。
これは、非常にうまくスケールしようとしています。
ここで、例外を見ていきましょう。

Portuguese: 
É sobre o mesmo conjunto de dados.
Mas o que posso fazer é defini id do player como minha chave de partição.
E isso significa, posso obter todos os dados para o player.
Portanto, se eu quisesse implementar um GetGameAsync
em seguida, eu apenas passo no meu player Id e identificação de jogo
e, em seguida, novamente, eu possa fazer um GET.
E, da mesma forma, se quiser localizar
todos os jogos de um jogador.
Eu sei que isso é por exemplo,
uma consulta de link, onde eu vejo player Id igual a player ID.
Portanto, isso é novamente uma consulta sequel
que é enviada para o back-end e de TI
ainda no escopo de uma chave de partição única.
Isso também é eficiente.
Portanto, que não era tão muito mais complicado, certo?
Portanto, se você tiver 1: n,
a chave é se você tiver essa hierarquia
deseja executar o pai de
a hierarquia de torná-la sua chave de partição.
E aqui novamente, podemos continuar com consultas de partição única
Assim como os primitivos restante, os primitivos torcida.
Portanto, isso vai ser realmente bem dimensionada.
Agora, vamos falar as exceções.

Korean: 
동일한 데이터 집합 끝났습니다.
하지만 내가 뭘, 내가 설정 되어 플레이어 id 내 파티션 키로.
즉, 모든 플레이어에 대 한 데이터를 볼 수 있습니까 하 고.
그렇게 하는 GetGameAsync를 구현 합니다.
그런 다음 방금 전달 해야 내 플레이어 Id 및 게임 Id
고를 GET을 수행할 수 있습니다.
마찬가지로 확인 하고자 하는 경우
모든 플레이어의 게임.
예를 들어 인지 모르겠지만
연결 쿼리를 어디에서 볼 플레이어 Id가 플레이어 id입니다.
따라서, 이것은 다시 게임의 속 편 쿼리
백 엔드 및 그에 게 보내지는
여전히 단일 파티션 키 범위가 제한 됩니다.
따라서 효율적 이기도 합니다.
따라서 그 하나는 훨씬 더 복잡 하, 오른쪽?
따라서, 1: n, 있는 경우
키가 있으면 해당 계층 구조
부모 하고자
계층 구조 파티션 키를 만듭니다.
여기 다시 우리가 종류를 단일 파티션으로 쿼리
물론 나머지 기본형 관중 기본 형식입니다.
따라서이 것 정말 쉽지입니다.
이제 우 자는 예외.

French: 
Il se trouve sur le même jeu de données.
Mais que faire, est définir un identificateur de lecteur comme ma clé de partition.
Et cela signifie, je peux obtenir toutes les données pour le lecteur.
Par conséquent, si je souhaite implémenter un GetGameAsync,
puis je simplement passer dans mon lecteur de Id et l’Id de jeu,
et, à nouveau, je peux faire un GET.
De même, si vous souhaitez rechercher
tous les jeux d’un lecteur.
Je sais qu’il s’agit, par exemple,
une requête de lien, où voir lecteur Id est égal à lecteur de code.
Alors, c’est à nouveau une requête de suite
qui est envoyé au back-end et ses
toujours une portée limitée à une clé de partition unique.
C’est également efficace.
Ainsi, un que c’est pas beaucoup plus compliquée, ce droit ?
Par conséquent, si vous disposez de 1 à n,
la clé est que si vous avez cette hiérarchie,
vous souhaitez tirer le parent
la hiérarchie de rend votre clé de partition.
Et ici, nous avons pour les requêtes de partition unique
Outre les primitives reste, les primitives de foule.
Cela va à l’échelle très bien.
Maintenant, nous allons apprendre aux exceptions.

Russian: 
Он находится над тем же набором данных.
Но что делать, я назначается код проигрывателя ключ раздела.
А это значит, я могу получить все данные для проигрывателя.
Таким образом, если нужно реализовать GetGameAsync
Затем я просто передаю в проигрыватель идентификаторы и игры,
а затем снова можно сделать GET.
И точно так же если требуется найти
все игры игрок.
Я знаю, что это так,
запрос ссылки, где я вижу, что проигрыватель Id равно проигрыватель идентификатор.
Таким образом это еще раз — второй шанс запрос
который отправляется внутренним и его
по-прежнему в пределах одной секции ключ.
Так что это также эффективно.
Таким образом, что не было, гораздо сложнее, право?
Таким образом, при наличии 1: n,
ключ является наличие этой иерархии
Чтобы воспользоваться родительского элемента
иерархии сделать ваш ключ раздела.
И здесь опять же, мы придерживаться одной секции запросов
а также примитивы остальные зрители примитивов.
Это будет действительно хорошо масштабируются.
Теперь займемся исключения.

Turkish: 
Bunun aynı veri kümesidir.
Ancak ne yapmam, ben player kimliği benim bölümü anahtar olarak ayarlanır.
Ve bunun anlamı, tüm player için veri alabilirsiniz.
Bunu, bir GetGameAsync uygulamak isterseniz,
sonra ben sadece benim player kimliği ve oyun kimliği geçti
ve daha sonra tekrar bir GET yapabilirsiniz.
Benzer şekilde ve bulmak istiyorsanız
oyuncu, oyunların tümünü.
Bu örneğin olduğunu biliyorum,
Burada kimliği player player kimliği eşittir görüyorum bir bağlantı sorgusu
Bu nedenle, bu yeniden bir sequel sorgusudur
arka uç ve kendi gönderilen
hala tek bölüm anahtarına kapsamlı.
Bu nedenle de etkili olur.
Böylece bir daha sağ, karmaşık, değildi?
Bunu, 1: n varsa,
Bu hiyerarşi varsa anahtarıdır,
üst almak istediğiniz
Hiyerarşi bölüm anahtarınızı olun.
Ve burada biz tek bölüm sorguları yeniden takılıyor
geri kalan ilkel yanı sıra, kaydolmak ilkel.
Bu nedenle bu gerçekten iyi ölçekleme oluyor.
Şimdi, diyelim ki özel durumlar alın.

Spanish: 
Es sobre el mismo conjunto de datos.
Pero, ¿qué hacer, se configurar id de jugador como mi clave de partición.
Y esto significa, puedo conseguir todos los datos para el Reproductor.
Por lo tanto, si deseaba implementar un GetGameAsync,
a continuación sólo paso mi Reproductor Id e Id de juego,
y, a continuación, de nuevo, puedo hacer un GET.
Y, del mismo modo, si deseo encontrar
todos los juegos de un jugador.
Sé que esto es por ejemplo,
una consulta de vínculo, dónde ver Reproductor Id es igual a Reproductor Id.
Por lo tanto, esto es una consulta sequel
que se envía el back-end y de TI
siguen limitándose a una clave de una única partición.
Por lo que también es eficaz.
¿Por lo que no era tan mucho más complicado, derecha?
Por lo tanto, si tiene 1: n,
la clave es que si tiene esa jerarquía
desea que el elemento primario de
la jerarquía facilitan la clave de partición.
Y aquí de nuevo, se pegan a las consultas de una única partición
así como las primitivas del resto, las primitivas multitud.
Así que esto va a escalar realmente bien.
Ahora, analicemos las excepciones.

German: 
Es ist das gleiche DataSet.
Aber wie ich ist ich Player-Id als meine Partitionsschlüssel.
Und, bekomme ich alle Daten für Player.
Wenn also ein GetGameAsync implementieren wollte,
dann übergebe ich nur meine Spieler und Spiele-Id,
und ich kann dann wieder ein.
-Gegebenenfalls suchen
alle Spiele ein Spieler.
Ich weiß, dass dies ist,
eine Link-Abfrage angezeigt, in dem Player Id Player ID entspricht
Dies ist wieder eine Fortsetzung Abfrage
Das Back-End und gesendet
eine einzelne Partition Schlüssel noch beschränkt.
Das ist außerdem effizienter.
Damit diese nicht komplizierter, rechts war?
Also, wenn Sie 1: n,
der Schlüssel ist der Hierarchie haben,
soll das übergeordnete Element
die Hierarchie erleichtern der Partitionsschlüssel.
Und hier wieder wir Einzelpartition Abfragen
sowie die übrigen primitive primitive Menge.
Dadurch wird gut skalieren.
Jetzt erfahren Sie in den Ausnahmen.

Italian: 
Cosa avviene quando si dispongono di gerarchie M:N?
L'idea in se si dispone di un gioco multiplayer,
è un popolare gioco virale,
non si tratta in realtà
la relazione padre-figlio in modo che si desidera
calcolare da Windows Media player, trovare dall'ID del gioco.
Pertanto i metodi che necessari sono get player dall'ID,
ottenere giochi in base all'ID, aggiungere gioco, gioco di rimuovere.
Che ottiene così un po' difficile.
In questo caso, vorrei analizzano
il nostro stesso repository se si dovesse estendere questa operazione.
>> Sì, vengono visualizzati molti giochi ora in
100 persone hanno su un'isola.
In questo caso, si dispone di centinaia di lettori
la riproduzione di centinaia di giochi,
ed è necessario gestire tutta la casa.
>> Sì, è una divertente problema.
Pertanto, in questo caso,
la cosa più semplice è, abbiamo un insieme.
Iniziamo con un insieme.
In questo caso, poiché siamo
Controlla in modo esplicito gli indici
perché il mio obiettivo era
illustra come ottenere le migliori prestazioni,
gli indici sia su player è ID e l'ID del gioco.
Gioco Get in base all'ID di Windows Media player è semplice,
che abbiamo appena visto in precedenza dopo la query di chiave di partizione.
>> A destra.
>> A questo punto, per quanto riguarda ottenere dall'ID del gioco?

Japanese: 
M:N の階層がある場合はどうすれば?
マルチ プレーヤー ゲームがある場合、考え中
これは一般的なウイルスによるゲームでは、
それは本当に
親と子の関係にするため
player で検索、ゲームの ID で検索
これに必要なメソッドは、ID でプレーヤーを取得
ID でゲームを取得、ゲームの追加、ゲームを削除します。
したがって、少し厄介なを取得します。
したがって、自分でしてくれる
この機能を拡張する場合は、同じリポジトリです。
>> はい、発生して多くのゲームのようになりました、
島に 100 人のユーザーがあります。
何百ものプレーヤーを持っているため、
何百ものゲームをプレイ
使用して、不動産のすべてを管理します。
>> はい、楽しいが問題です。
ここでは、
最も簡単なですが、1 つのコレクションです。
1 つのコレクションから始めましょう。
ここでは、もう一度ため
インデックスを明示的に制御すること
私の目標であるため
最高のパフォーマンスを取得する方法を示す
インデックス ID とゲーム ID は両方のプレーヤーがあります。
Get のゲームでプレイヤーの ID は簡単で、
だけをパーティション キーのクエリの前にしました。
>> 権限。
>> これで、ゲームの ID で取得についてでしょうか。

Russian: 
Что делать при наличии иерархии m: n?
Идея, если у вас есть многопользовательские игры,
Это популярная игра популярным,
Затем он не действительно
связи "родитель потомок", требуется
определить проигрыватель, игры идентификатором.
Поэтому методы, которые требуются, проигрыватель get по Идентификатору,
получить игры по Идентификатору, добавить игры, удаление игры.
Таким образом, получает немного сложнее.
Итак давайте обсудим то
Наши же репозитория если бы мы это расширение.
>> Да, я вижу много игр теперь где
они имеют 100 человек на острове.
Таким образом у вас сотни игроков
сотни игр, воспроизведения
и управление всем операциям с недвижимостью.
>> Да, это снабдить проблему.
Таким образом в данном случае
является простым вещь, у нас есть одна коллекция.
Давайте начнем с одной коллекции.
Здесь, опять же, потому что мы
явно Управление индексами
Поскольку моя цель
Показывает, как для обеспечения высокой производительности
индексы имеют оба проигрывателя на код и код игры.
Игра получить по Идентификатору проигрыватель прост,
Мы только что увидели, что ранее после запроса ключа секции.
>> Право.
>> Теперь как насчет получить по Идентификатору игры?

English: 
What do you do when you have M:N hierarchies?
The idea being if you have a multi-player game,
it's a popular viral game,
then it's not really
the parent-child relationship so you want to
find by player, find by game ID.
So the methods you need are get player by ID,
get game by ID, add game, remove game.
So that gets a little bit tricky.
So, let me walk you through
our same repository if we were to extend this.
>> Yes, I'm seeing a lot of games now where
they have 100 people on an island.
So, you've got hundreds of players
playing hundreds of games,
and you have to manage all of the estate.
>> Yeah, it's a fun problem.
So, in this case,
the simplest thing is, we have one collection.
Let's start with one collection.
Here, again, because we
are explicitly controlling indexes
because my goal was
showing how to get the best performance,
you have indexes both on player ID and game ID.
Get game by player ID is simple,
we just saw that earlier after the partition key query.
>> Right.
>> Now, what about get by game ID?

Polish: 
Co zrobić gdy masz m: n hierarchie?
Trwa pomysł, jeśli masz gry dla wielu graczy,
to popularna gra wirusowe,
to nie jest naprawdę
relacji nadrzędny podrzędny, tak aby
Znajdź przez program player, Znajdź według identyfikatora gier.
Tak więc metody, które są potrzebne są get odtwarzacza przez identyfikator,
Gra według identyfikatorów, dodać grę, usunąć gry.
Tak że pobiera trochę skomplikowane.
Tak więc Pozwól mi przejść przez
nasze repozytorium samego Gdybyśmy to rozszerzenie.
>> Tak, widzę wiele gier teraz gdzie
mają one 100 osób na wyspie.
Tak masz setki graczy
setki gier, gry
i trzeba zarządzać cały majątek.
>> tak, to dobry problem.
Tak w tym przypadku,
Najprościej jest, mamy jedną kolekcję.
Zacznijmy od jednej kolekcji.
Tu, ponownie, ponieważ firma Microsoft
są jawnie kontrolowanie indeksów
ponieważ moim celem było
pokazano, jak uzyskać najlepszą wydajność,
mają indeksy zarówno gracza na identyfikator i identyfikator gier.
Gra Get przez identyfikator odtwarzacza jest prosta,
po prostu widzieliśmy wcześniej po kwerendy klucza partycji.
>> Do prawej.
>> Teraz co się przez identyfikator gier?

Portuguese: 
O que fazer quando você tem hierarquias M:N?
A ideia, sendo que se você possuir um jogo de vários jogadores
é um popular jogo viral,
em seguida, ele não é realmente
a relação pai-filho para que você deseja
Localizar pelo player, localizar pela ID do jogo.
Então, os métodos que você precisa são get player por ID,
obter jogo por ID, adicionar jogo, remover o jogo.
Que obtém um pouco confuso.
Portanto, vou orientá-lo
nosso repositório mesmo se fôssemos estender esse desempenho.
>> Sim, estou vendo muitos jogos agora onde
eles têm 100 pessoas em uma ilha.
Portanto, você tem centenas de jogadores
reprodução de centenas de jogos,
e você precisa gerenciar todos os bens.
>> Sim, é um divertido problema.
Portanto, nesse caso,
a coisa mais simples é que temos uma coleção.
Vamos começar com uma coleção.
Aqui, mais uma vez, pois estamos
explicitamente está controlando índices
porque meu objetivo era
mostrando como obter o melhor desempenho
Você tem índices tanto no player ID e ID de jogo.
Jogo de Get por ID do player é simple,
que acabamos de ver que anteriormente após a consulta de chave de partição.
>> À direita.
>> Agora, que tal obter pela identificação do jogo?

Korean: 
M:N 계층 구조를가지고 있을 때 어떻게 해야 할까요?
멀티 플레이어 게임을 하는 경우 생각 되는
그는 인기 있는 바이러스 게임,
않으면 정말
부모-자식 관계를 만들려고
플레이어가 게임 id 찾기,
따라서 필요한 메서드는 get 플레이어 ID로
가져올 ID로 게임, 게임을 추가, 제거 게임.
따라서 조금 까다로운를 가져옵니다.
안내를 해 드리죠
우리 같은 저장소가 경계를 확장 하는 것입니다.
>> 예, 못한 많은 게임 지금 여기서
섬에 있는 100 명.
따라서 플레이어의 수백 있어요
수많은 게임을 재생합니다.
모든 부동산은 관리 해야 합니다.
>>는 재미는 물론 문제가 있습니다.
이 경우에 따라서
가장 간단한 것 이면 컬렉션은 한 가지.
하나의 컬렉션으로 시작 해 보겠습니다.
여기서 또 있기 때문에 우리
인덱스를 명시적으로 제어 하는
했습니다 있기 때문에
최상의 성능을 얻으려면 방법 표시
인덱스 번호와 게임 번호에 두 플레이어를가지고
플레이어 ID로 get 게임은 간단 합니다.
방금 살펴본 하는 파티션 키 쿼리 후 이전.
>> 권한입니다.
>> 이제 게임 ID로 얻을 어떨까요?

Czech: 
Co uděláte, když máte M:N hierarchie?
Právě nápad, pokud máte hru více hráčů
To je populární hra virové,
pak není ve skutečnosti
vztah nadřazený podřízený, který chcete
hledání pomocí přehrávače, hledání podle ID hry.
To jsou metody, které potřebujete získat přehrávač podle ID,
získání hry podle ID, hru přidat, odebrat hry.
Který získá tak trochu záludné.
Manuální, provede vás
Naše stejné úložiště, kdyby jsme to rozšířit.
>> Ano, dostávám spoustu her nyní kde
na ostrově mají 100 osob.
Ano máte k dispozici stovky hráčů
stovky her, přehrávání
a je třeba spravovat všechny majetkové podstaty.
>> Ano, je zábavné problém.
Ano v tomto případě
je nejsnazší je máme jednu kolekci.
Začněme jedna kolekce.
Zde znovu, protože jsme
jsou explicitně řízení indexy
vzhledem k tomu, že byl Můj cíl.
Jak získat nejlepší výkon, zobrazení
indexy mají oba na přehrávač ID a game ID.
Získat hru podle ID přehrávače je jednoduchý,
jsme právě viděli, který dříve po dotazu klíče oddílu.
>> Doprava.
>> Nyní jak dosáhnout game ID?

Turkish: 
M hiyerarşileri olduğunda ne yapacaksınız?
Çok oyunculu oyun varsa fikir olmasının,
popüler virüslü oyun olduğu,
sonra gerçekten değil
Böylece, istediğiniz üst-alt ilişkisi
Player'ın bulmak, oyun ID'LERİNE göre Bul
Bu nedenle gerek get player kimliği tarafından yöntemlerdir,
Kimliğe göre oyun almak, oyun eklemek, oyunu kaldırın.
Bu nedenle, biraz zor alır.
Bu nedenle, izlenecek yol istiyorum
Bu genişletmek için olsaydık bizim aynı depo.
>> Evet, oyunlar bir sürü şimdi nerede görüyorum
Bunlar, bir adada 100 kişi vardır.
Bu nedenle oyuncular yüzlerce var
yüzlerce oyun oynama,
ve tüm Emlak yönetmek zorunda.
>> Evet, eğlenceli bir olduğunu sorun.
Bu nedenle, bu durumda
en basit şey biz bir koleksiyona sahip değil.
Bir koleksiyon ile başlayalım.
Burada, yine, çünkü biz
açıkça dizinler kontrol etme
Benim hedef olduğundan
en iyi performansı elde etmek nasıl gösteren,
dizinler üzerinde her iki player kimliği ve oyun kimliği var
Player kimliği tarafından Get oyun basittir,
yalnızca, önceki bölüm anahtar sorguyu sonra gördük.
>> Sağ.
>> Şimdi, oyun ID ile ne elde?

Spanish: 
¿Qué hace cuando tienen jerarquías m: n?
La idea que se está si tiene un juego de varios jugador
es un popular juego viral,
a continuación, en realidad no es
la relación de elementos primarios y secundarios, por lo que desee
Buscar por Reproductor, buscar por identificador de juego.
Por lo que los métodos que necesita son get Reproductor por Id.,
obtener juego por ID, agregar juego, quitar el juego.
Que obtiene un poco más complicado.
Por lo tanto, voy a guiarle a través de
nuestro repositorio mismo si tuviéramos que ampliar este principio.
>> Sí, estoy viendo muchos juegos ahora donde
tienen 100 personas en una isla.
Por lo tanto, tiene cientos de jugadores
jugando cientos de juegos,
y tendrá que administrar todas las raíces.
>> Sí, es un divertido problema.
Por lo tanto, en este caso,
lo más sencillo es, tenemos una colección.
Comencemos con una colección.
Aquí, de nuevo, porque nos
se controle explícitamente de índices
ya que mi objetivo era
que muestra cómo obtener el mejor rendimiento,
tener índices de ambos en el Reproductor de identificador y el juego.
Juego de Get por ID del Reproductor es simple,
acabamos de ver anteriormente después de la consulta de clave de partición.
>> Derecho.
>> Ahora, ¿qué hay de conseguir por ID del juego?

French: 
Que faire lorsque vous avez des hiérarchies de n : n ?
L’idée en cours si vous avez un jeu multijoueur,
Il s’agit d’un célèbre jeu viraux,
Il n’est pas vraiment
la relation parent-enfant, afin que vous le souhaitez
Rechercher par le lecteur, rechercher par ID de jeu.
Par conséquent, les méthodes dont vous avez besoin sont lecteur get par ID,
obtenir le jeu par ID, ajouter jeu, supprimer le jeu.
Par conséquent, qui obtient un peu complexe.
Donc, permettez-moi de vous guider
notre référentiel même si nous devions étendre ce.
>> Oui, j’aperçois un grand nombre de jeux maintenant où
ils ont 100 personnes sur une île.
Ainsi, vous avez des centaines de joueurs
lecture des centaines de jeux,
et vous devez gérer l’ensemble du patrimoine.
>> Oui, c’est un plaisir problème.
Par conséquent, dans ce cas,
est la chose la plus simple, nous disposons d’une collection.
Commençons avec une collection.
Ici, aussi, parce que nous
Contrôlez explicitement des index
car mon objectif était
montrant comment obtenir les meilleures performances,
vous avez des index à la fois sur le lecteur code et jeux.
Jeu de Get par un identificateur de lecteur est simple,
Nous avons vu juste que plus haut après la requête de clé de partition.
>> Droite.
>>, Qu’en est-il maintenant par ID de jeu ?

German: 
Was tun, wenn teilnehmen Hierarchien haben?
Die Idee haben Sie ein Multiplayer-Spiel, sondern
Dies ist ein beliebtes virale Spiel,
dann ist es nicht wirklich
hierarchische Beziehung Sie also
finden von Player, Spiele-ID
So sind die benötigten Methoden Get Player nach ID
Spiel nach ID Spiel hinzufügen, entfernen, Spiel.
So wird das etwas kompliziert.
Lassen Sie mich Sie durchlaufen
Unsere dasselbe Repository wäre dies erweitern.
>> Ja, viele Spiele jetzt, sehe ich
Sie haben 100 Personen auf einer Insel.
So haben Hunderte Spieler haben
Hunderte von Spiele spielen
und Sie verwalten die Anzeigefläche.
>> Ja, es ist ein Problem.
In diesem Fall also
Das einfachste ist haben eine Auflistung.
Beginnen wir mit einer Sammlung.
Hier, weil wir
Indizes sind explizit steuern.
Mein Ziel war
Zeigt, wie Sie die beste Leistung zu erzielen,
Sie haben Indizes auf Spieler ID und game-ID.
Get-Spiel vom Player-ID ist einfach,
Wir haben gerade gelernt, die früher nach Partition Key-Abfrage.
>> Recht.
>> Jetzt, was Spiel ID erhalten?

Chinese: 
當您有 M:N 階層您該怎麼辦？
概念，是如果您有多人遊戲時，
這是常見的病毒遊戲，
然後這根本就不
父子式關聯性，因此您想要
播放程式尋找、 尋找遊戲 id。
因此您需要的方法會取得播放程式識別碼，
取得 id 的遊戲將遊戲新增、 移除遊戲。
因此，取得處理起來有點棘手。
因此，我要帶您逐步完成
我們相同的儲存機制如果我們來擴充這。
>>，我看到很多遊戲現在位置
它們可以有 100 位在一座小島上。
因此，您有數百個玩家
播放遊戲、 數百
而且您需要管理所有的空間。
>> 很有趣的是，問題。
因此，在此情況下，
最簡單的事是，我們有一個集合。
讓我們從開始一個集合。
這裡，同樣地，因為我們
明確控制索引
因為我的目標是
顯示如何取得最佳的效能，
索引您有兩個在播放程式識別碼及遊戲的 id。
取得遊戲的播放程式識別碼很簡單，
我們剛才所見的磁碟分割的索引鍵查詢之後，更早版本。
>> 權限。
>> 現在，怎麼取得遊戲的 id？

Chinese: 
必须 M:N 层次结构时，您该怎么办？
想法是如果您有多个玩家的游戏
这是一个流行的病毒游戏，
然后它并不是
因此要父-子关系
播放机通过查找、 查找游戏 id。
因此您需要的方法是按 ID，获取播放机
获取游戏 id，将游戏添加，移除游戏。
因此，获取得有点棘手。
因此，让我将指导您完成
如果我们要扩展此我们同一个库。
>> 的我能看到大量的游戏现在位置
他们在岛上有 100 人。
因此，您有数百个玩家
玩游戏数百
也可以管理所有的不动产。
>> 是，它是有趣的问题。
因此，在这种情况下，
最简单的方法是，我们有一个集合。
让我们开始与一个集合。
这里，同样，因为我们
显式控制索引
因为我的目标是
显示如何获取最佳性能，
具有索引这两种上播放机 ID 和游戏 id。
由播放机 ID 获取游戏很简单，
我们刚才看到的在分区键查询后前面。
>> 的权限。
>> 现在，怎样获取游戏 id？

Russian: 
Теперь обратите внимание, что не является ключом раздела правой?
Итак, что же делать вот
Если это редко, это большой, если
Обычно, если у нас есть какой-либо оператор где
Большинство запросов имеют код проигрывателя
и редкие идентификатором игры
Затем можно перейти сделать через раздел запроса.
>> У вас решить, что редко означает для вас?
Вы сказали, если это редко.
Что такое редкие? Ежедневные?
>> Я бы сказал, если это 90,10 смесь, грубо говоря.
Это эмпирическое правило. Не так часто.
>>, Имеет смысл.
>>, Но что делать, если чаще всего?
В некоторых случаях может быть наборе 50/50 правой?
>> Право.
>> Это где необходимо изменить канал на помощь.
Итак Предположим, вы хотите, чтобы
другой сводной таблицы той же коллекции
который имеет идентификатор игры как ключ раздела.
Таким образом будет иметь копию
эту коллекцию, которая имеет ключ другой раздел.
И Предположим, у вас есть те же данные,
Теперь можно выполнять поиск с кодом игры.
Теперь эта проблема решена,

French: 
Notez maintenant, qu'il n’est pas une clé de partition, droite ?
Par conséquent, que faire ici est
s’il est rare, c’est une grande si,
généralement s’il y a un type d’opérateur où
la plupart des requêtes ont un identificateur de lecteur
et rarement utilisée par un ID de jeu
Vous pouvez passer de faire un sur la requête de la partition.
>> Ne vous devez décider quels moyens peu fréquentes pour vous ?
Vous dit si il est rare.
Ce qui est peu fréquent ? Tous les jours ?
>> Je dirais que si elle est une combinaison de 90,10, à peu près en parlant.
Il s’agit d’une règle générale. Pas souvent.
>> Qui est logique.
>>, Mais que se passe-t-il si elle est souvent ?
Dans certains cas, il peut y avoir une combinaison 50/50, droite ?
>> Droite.
>> Il s’agit d’où vous n’avez modifié d’alimentation à la rescousse.
Ainsi, supposons que vous vouliez
un autre tableau de croisé dynamique de la même collection
qui a l’ID de jeu en tant que votre clé de partition.
Ainsi, vous aurez un clone de
Cette collection possède une clé de partition différent.
Et disons que vous avez les mêmes données que
Vous pouvez désormais effectuer des recherches sur les ID de jeu.
À présent, ce problème est résolu,

Turkish: 
Şimdi, fark sağ bölüm anahtarı değil mi?
Bu nedenle, ne yaparsınız İşte
seyrek ise, bu bir büyük olur,
genellikle biz bazı tür işleç varsa burada
en çok istekte player kimliği vardır.
ve oyun Kimliğe göre seyrek,
yapmak gidin sonra bir bölümü sorgu arasında.
>> Seyrek hangi anlamına gelir size karar vermek zorunda mıyım?
Seyrek olup olmadığını söylediğinizi.
Seyrek nedir? Günlük?
>> I 90,10 bir karışımı olan kabaca Konuşmayı diyor.
Başparmak bir kuraldır. Genellikle değil.
>>, Bir anlamı yoktur.
>>, Ancak genellikle ne olur?
Bazı durumlarda, doğru 50/50 bir karışımı olabilir?
>> Sağ.
>>, Kurtarma için besleme değişikliği olduğu budur.
Bu nedenle, istediğinizi varsayalım
Aynı koleksiyon için başka bir Özet
Oyun kimliği, bölümü anahtar olarak sahip olduğu.
Bu nedenle, bir kopyası vardır
farklı bölüm anahtarı olan bu koleksiyonu.
Ve aynı verilere sahip diyelim,
Artık oyun kimliği karşı aramalar gerçekleştirebilirsiniz.
Şimdi, bu sorun Çözüldü,

Czech: 
Nyní Všimněte si, že je klíč oddílu, vpravo?
To, co můžete udělat je zde
Pokud je málo časté, to je velký
obvykle Pokud máme nějaký druh operátor kde
Většina požadavků mají ID přehrávače
a zřídka game ID,
potom můžete přejít přes oddíl dotazu.
>> Je nutné rozhodnout, jaký zřídka znamená pro vás?
Řečeno, pokud je málo časté.
Co je zřídka? Denní?
>> By říci Pokud je 90,10 mix, mluvit hrubě.
Je pravidlo palce. Ne často.
>>, Smysl.
>> Ale co když je často?
V některých případech může být 50/50 mix doprava?
>> Doprava.
>> To je, kde jste změnu krmiva pomoc přichází.
Takže Řekněme, že jste chtěli
jiné kontingenční tabulky ze stejné kolekce.
který má game ID jako klíč oddílu.
Proto budete mít klon
tuto kolekci, která má klíč jiný oddíl.
A Řekněme, že máte stejná data,
Nyní můžete provádět vyhledávání proti ID hry.
Nyní je tento problém vyřešen,

Polish: 
Teraz można zauważyć, że nie jest klucz partycji, prawo?
Tak więc, co zrobić, Oto
Jeśli jest to rzadko, jest to duży, jeśli
Zazwyczaj, jeśli mamy jakieś operatora gdzie
Większość żądania ma identyfikator odtwarzacza
i rzadko wykonywane przez identyfikator gier,
następnie można przejść, czy całej partycji kwerendy.
>> Masz może zdecydować, co oznacza rzadko do Ciebie?
Twierdzi się, jeśli jest rzadko.
Co to jest rzadko? Dzienne?
>> Chciałbym powiedzieć, czy to połączenie 90,10, ogólnie rzecz biorąc.
Jest to reguła kciuka. Często nie.
>> To ma sens.
>>, Ale co zrobić, jeśli jest często?
W niektórych przypadkach może być 50/50 zarówno prawo?
>> Do prawej.
>> Jest to gdzie mają zmiany paszy do ratowania.
Tak więc Powiedzmy, że chcesz
innego diagramu przestawnego tej samej kolekcji
jako klucz partycji, która ma identyfikator gier.
Tak więc miałoby klon
tej kolekcji, która ma klucz inną partycję.
I Załóżmy, że użytkownik ma te same dane które
Teraz można wykonywać wyszukiwania identyfikatora gier.
Teraz ten problem jest rozwiązany,

Portuguese: 
Agora, observe que não é uma chave de partição, certa?
Então, o que fazer aqui é
Se for raros, isso é um grande se,
geralmente se tivermos algum tipo de operador onde
a maioria das solicitações têm uma ID do player
e esporádicos por um ID de jogo
em seguida, você pode ir a fazer um em consulta de partição.
>> Você tem que decidir quais pouca significa para você?
Você disse que se é pouco frequente.
O que é pouco frequente? Diários?
>> Eu diria se é uma mistura de 90,10, em termos gerais.
É uma regra geral. Não com frequência.
>> Que faz sentido.
>>, Mas e se costuma ser?
Em alguns casos, pode ser uma combinação 50/50, certa?
>> À direita.
>> Isso é onde você tem que alterar a alimentação para o resgate.
Então, digamos que você queria
outra dinâmica da mesma coleção
que tem jogo ID como a chave da partição.
Assim, você teria um clone do
Essa coleção que tem uma chave de partição diferente.
E, digamos que você tenha os mesmos dados que
Agora você pode executar pesquisas em relação a ID do jogo.
Agora, esse problema foi resolvido,

Chinese: 
現在，請注意它不是磁碟分割索引鍵，正確嗎？
因此，該怎麼辦如下
如果很少用，如果這是大，
通常如果我們有某種運算子時，才位置
點閱次數最多有播放程式識別碼
並不常見，遊戲的識別碼，
然後您可以執行跨磁碟分割的查詢。
>> 您必須決定哪些少用的方法，以您嗎？
您所說，是否它是不常見。
什麼是少用的？每日？
>> 我認為它是否 90,10 混合時，大約說話。
它是一個縮圖的規則。不常。
>> 這很合理。
>> 但萬一它是通常呢？
在某些情況下，可能是 50/50 混合時，正確嗎？
>> 權限。
>> 這是您用來讓餵送可放在拯救的變更。
因此，假設您想要
同一集合中的另一個樞紐分析
磁碟分割索引鍵具有的遊戲 ID。
因此，您就必須的複製品
這個集合含有不同的磁碟分割的索引鍵。
並假設您有相同的資料，
現在您可以在其中執行查閱對遊戲 id。
現在，解決此問題，

German: 
Beachten Sie, ist kein Partitionsschlüssel rechts?
Also, was tun Sie hier
Wenn es selten ist, ist dies ein großes,
Normalerweise haben wir eine Art von Operator,
Die meisten Anfragen haben eine Player-ID
und selten durch eine Spiel-ID
Fahren Sie führen einen gesamten Partition Abfrage.
>> Müssen Sie entscheiden, was selten bedeutet für Sie?
Sie sagte ist selten.
Was ist selten? Tägliche?
>> Würde ich eine 90,10 Mischung ist grob.
Es ist eine Faustregel. Häufig nicht.
>> Sinnvoll.
>>, Aber wenn es ist häufig?
In einigen Fällen möglicherweise eine 50: 50 Mischung Rechte?
>> Recht.
>> Dies ist, wo die Rettung feed ändern.
So, nehmen wir an, Sie möchten
anderen PivotTable derselben Auflistung
Spiel-ID als Ihre Partitionsschlüssel hat.
So müssen Sie auf einen Klon
Diese Sammlung hat einen andere Partitionsschlüssel.
Angenommen, Sie haben die gleichen Daten,
Sie können jetzt Suchvorgänge für game ID ausführen
Dieses Problem ist jetzt gelöst,

Italian: 
Si noti a questo punto, che non è una chiave di partizione, destra?
In questo caso, cosa facciamo qui è
Se è poco frequente, si tratta di una grande se,
in genere se si dispone di un tipo di operatore in
numero di richieste più dispone di un ID di Windows Media player
e occasionali da un ID di gioco,
quindi è possibile effettuare una tra query di partizione.
>> È necessario decidere quali mezzi poco frequenti per l'utente?
Si dice se è insolito.
Che cos'è poco frequenti? Ogni giorno?
>> Direi se è una combinazione di 90,10, parlare più o meno.
Si tratta di una regola di thumb. Non spesso.
>> Ha un senso.
>> Ma cosa succede se è spesso?
In alcuni casi, potrebbe essere una combinazione di soluzione 50/50, destra?
>> A destra.
>> Questo è in modifica feed in soccorso.
In questo caso, si supponga che si desidera
un altro pivot nell'insieme
ID del gioco che ha come chiave di partizione.
In questo caso, è un duplicato di
Questo insieme dispone di una chiave di partizione diverso.
E supponiamo di disporre degli stessi dati che
a questo punto è possibile eseguire ricerche con l'ID del gioco.
A questo punto, il problema viene risolto,

Spanish: 
¿Ahora, observe que no es una clave de partición correcta?
Así que, ¿qué hace aquí es
Si es poco frecuente, esto es un gran si,
Normalmente, si tenemos algún tipo de operador donde
la mayoría de las solicitudes tienen un identificador de Reproductor
y poco frecuente por un identificador de juego,
Vaya a hacer una a través de la consulta de la partición.
¿>> Tendrá que decidir qué significa poco frecuente para usted?
Usted dijo que si es poco frecuente.
¿Qué es poco frecuente? ¿Diario?
>> Diría si es una mezcla de 90,10, en términos generales.
Es una regla de control de posición. No es muy común.
>> Tiene sentido.
>> Pero ¿qué ocurre si a menudo?
¿En algunos casos, puede haber una combinación 50/50, derecho?
>> Derecho.
>> Esto es donde tienes que cambiar fuente al rescate.
Por lo tanto, digamos que desea
otra dinámica de la misma colección
ID del juego que tiene como clave de partición.
Por lo tanto, tendría un clon de
Esta colección que tiene una clave de partición diferente.
Y supongamos que tiene los mismos datos que
Ahora puede realizar búsquedas de ID de juego.
Ahora, este problema se ha resuelto,

Chinese: 
现在，注意到不正确的分区键？
那么，您该怎么办是
如果它不是很频繁，如果这是大，
通常，如果我们有某种类型的运算符，
请求最多有一个玩家 ID
并不太频繁的游戏 ID，
然后您可以转做跨分区查询。
>> 您需要决定对您意味着什么少吗？
您说是否它不是很频繁。
很少是什么？每日吗？
>> 我想说是否它是 90,10 混合，大致讲。
这是拇指规则。不经常。
>> 这是可以理解。
>>，但通常会怎么办？
在某些情况下，可能有 50/50 的组合，合适吗？
>> 的权限。
>> 这是您有更改源挽救。
因此，假设您想要的
同一集合中的另一个数据透视表
分区键具有游戏 ID。
因此，您必须的克隆
这其中都有一个不同的分区键的集合。
假设您有相同的数据和程序
现在，您可以执行查找针对游戏 id。
现在，被解决此问题，

Korean: 
이제 오른쪽 파티션 키 아닙니다 발견?
따라서 어쩌 같습니다.
잦은 없으면 이것이 아니 야,
연산자의 종류는 경우에 일반적으로 위치
대부분의 요청 플레이어 ID가
게임 id로 자주 하 고
않는 이동할 수 있습니다 다음은 파티션 쿼리를 통해.
>> 있습니까 결정에 드물게 어떤 방법?
잦은 경우 말한.
잦은 아닌 것은? 매일?
>> 라고 할 90,10 혼합 인지 대략 말하기.
그는 엄지 규칙입니다. 종종 되지 않습니다.
>> 하는 것이 좋습니다.
>> 하지만 어떻게이?
경우에 따라 오른쪽 50/50 목록 있을 수 있습니다?
>> 권한입니다.
>> 이것은 피드를 들자면 변경 해야 합니다.
따라서 원하는 경우를 가정해
동일한 컬렉션에 대 한 다른 피벗
파티션 키로 게임 ID가 있습니다.
따라서 복제 해야
다른 파티션 키가이 컬렉션입니다.
동일한 데이터를가지고 있다고 가정 하는
이제 게임 id입니다.에 대 한 조회를 수행할 수 있습니다.
이 문제를 해결

English: 
Now, notice it's not a partition key, right?
So, what do you do here is
if it's infrequent, this is a big if,
usually if we have some kind of operator where
most requests have a player ID
and infrequent by a game ID,
then you can go do a across partition query.
>> Do you have to decide what infrequent means to you?
You said if it's infrequent.
What's infrequent? Daily?
>> I would say if it's a 90,10 mix, roughly speaking.
It's a thumb rule. Not often.
>> That makes sense.
>> But what if it's often?
In some cases, there might be a 50/50 mix, right?
>> Right.
>> This is where you have change feed to the rescue.
So, let's say you wanted
another pivot of the same collection
which has game ID as your partition key.
So, you would have a clone of
this collection which has a different partition key.
And let's say you have the same data that
now you can perform lookups against game ID.
Now, this problem is solved,

Japanese: 
パーティション キー、右ではありませんが、わかりますか。
では、どうすれば次のとおりです
頻繁な場合は、これが大きな場合は、
いくつかの種類の演算子がある場合は通常、
要求のほとんどは、プレイヤー ID を持つ
ゲームの id では、まれに発生し
操作を移動することができますし、パーティションのクエリにします。
>> どのような頻度の低い手段を決定する必要がを実行しますか。
したかどうかは、頻繁にはありません。
頻繁にはないものでしょうか。毎日でしょうか。
>> と言えるかどうかは、90,10 のミックスでは、大まかに言うとします。
親指のルールです。あまり。
>> は理にかなっています。
>> が場合があります。
、場合によっては、50/50 のミックス、右がある可能性がありますか。
>> 権限。
>> は、復旧に変更があります。
そのため、場合を考えてみましょう
同じコレクションの他のピボット
パーティション キーがゲームの ID です。
クローンを作成する必要が、
別のパーティション キーを持つコレクションです。
同じデータがあるとしています。
ゲーム ID に対して検索を実行するようになりました
ここで、この問題が解決したら、

Portuguese: 
o problema de pesquisa chave de partição é resolvido.
Mas como você preencher esses dados?
>> Sim e usando um clone
é necessário manter isso atualizado?
Qual é a fonte com autoridade?
>> Corrigi. Direitos de duplos
males de direitos duplos.
Como o que acontece se um
falhar, o outro for bem-sucedida, certo?
Feed de alteração permite que espero determinístico
Manter controle das alterações conforme eles chegam.
Portanto, você tem a recuperação de falhas, você tem a escala.
Por exemplo, se você pode desenhar um
monte de sabe qual é a utilidade
eles podem fazer balanceamento de carga, coisas dessa natureza.
Portanto, esta é títulos bare alterar campo API.
Certo? Portanto, se você olhar intervalos de chave de partição,
a maneira como isso funciona é que você tem
real acesso direto aos intervalos de chaves de partição
e você pode recuperar as alterações
das partições de forma independente.
A vantagem disso é agora, por exemplo,
Eu pode acionar vários trabalhadores
nele e pode transformar isso em parlor,
e dissipe todas as alterações que chegam.
Basicamente, é o código que funciona aqui
essencialmente um único são absurd documento que acho.

Chinese: 
磁碟分割索引鍵查閱會解決問題。
但是，您該如何填入此資料嗎？
>> [是]，使用複製品，
必須注意此點最新狀態嗎？
哪一個是授權的來源？
>> 更正。雙精度浮點的權限，
雙精度浮點的權限的 evils。
就像的話，會發生什麼事
失敗，其他執行成功，權限？
變更摘要會提供該決定性的希望，
進入時，持續追蹤的變更。
因此，您有失敗復原，您必須橫向擴充。
例如，如果您可以繪製
在知道什麼用處的堆
它們可以進行負載平衡，該性質的項目。
因此這是裸機債券會變更欄位的 API。
對吧？因此，如果您要查看的磁碟分割的索引鍵範圍，
這個運作的方式是您必須
實際直接存取的磁碟分割金鑰的範圍
您可以擷取變更
從這些磁碟分割獨立。
這樣的好處是現在，比方說，
我可以把多個工作者
在其上，我可以將這 parlor，在
然後，會耗盡所有傳入的變更。
最後，這裡的運作方式的程式碼是
基本上單一量子力學文件我認為。

Turkish: 
Bölüm anahtar arama sorun çözülür.
Ancak bu verileri nasıl doldurmak?
>> Evet ve bir Klonla'yı kullanma
Bu güncel tutmak zorunda mıyım?
Hangi yetkili kaynak değil misiniz?
>> Düzeltin. Çift hakları
çift haklarının evils.
Ne gibi bir olur
başarısız olursa, diğer, sağ başarılı olur?
Değişiklik besleme, o kararlı ümit için verir
değişiklikler geldikleri gibi izlemek.
Hata kurtarma, böylece yatay ölçekli vardır.
Örneğin, çizim, bir
Bunu iyi bilen birini bırakılmazsa,
yapmak için Yük Dengeleme, o Doğa şeylerle.
Bu nedenle çıplak TAHVİLLERİ alan API değiştirin.
Sağ? Bölüm anahtar aralıkları bakarsanız bunu
Bu çalışma biçimini, sahip olduğu
bölüm anahtarlarını aralıklarını gerçek doğrudan erişim,
ve değişiklikleri alabilir
Bu bölümleri bağımsız olarak.
Bu güzelliği, örneğin sunulmuştur,
Birden fazla çalışanlar atmak
Bunun üzerinde ve ben bu parlor içinde açmak
ve içinde gelen tüm değişiklikleri Boşalt.
Sonuçta, burada çalışan kodudur
Sanırım aslında tek absurd bir belge.

Japanese: 
パーティション キーの検索の問題を解決します。
ですが、このデータを設定するのでしょうか。
>> [はい]、および、クローンを使用しました。
この最新の状態する必要がありますか。
権限のあるソースのどれですか。
>> を修正します。二重権限は、
二重の権利がまし。
1 つの場合と同様に
失敗した場合、他の成功すると、右か。
変更のフィードを使用すると、確定的な期待に
変更を追跡来たとします。
障害の回復があるため、スケール アウトがあります。
描画する場合など、
一連のでは、何の役を知っています。
ロード ・ バランシング、その性質のものです。
したがって、これは裸の債券は、フィールドの API を変更します。
そうです。パーティション キーの範囲を確認する場合は
これが機能する方法は、
、パーティション キーの範囲を実際のダイレクト アクセス
変更を取得することができ、
パーティションいない独立しています。
これの利点は、ここで、します。
複数の作業者をスローすることができます。
parlor でこれにすることができ、
付属している変更をすべて放電します。
ここで動作するコードは、最終的には、します。
本質的に 1 つ不合理なドキュメントだと思います。

Spanish: 
se ha resuelto el problema de la búsqueda de clave de partición.
¿Pero, cómo rellenar estos datos?
>> Sí y con un clon
¿Tengo que mantenerlo actualizado?
¿Cuál es el origen autorizado?
>> Correcta. Derechos de doble
los males de derechos dobles.
Al igual que lo que ocurre si uno
¿se produce un error, el otro tiene éxito, derecha?
Cambiar fuente da que espero determinista
realizar un seguimiento de cambios, tal y como vienen.
Así que tiene la recuperación de errores, haya escalado.
Por ejemplo, si se puede dibujar un
montón de sabe qué bueno en ella,
hacen equilibrio de carga, las cosas de esa naturaleza.
Así que este es el pelado bonos cambian campo API.
¿Correcto? Por ello, si mira los intervalos de clave de partición,
el modo de funcionamiento es que tiene
real acceso directo a los intervalos de claves de partición
y puede recuperar cambios
independientemente de las particiones.
Lo bueno de esto es ahora, por ejemplo,
¿Puedo subir varios trabajadores
en él y puedo convertir esto en el salón,
y vacíe todos los cambios que se incluyen en.
Finalmente, el código que funciona aquí es
esencialmente un único absurdo documento que pienso.

Korean: 
파티션 키 조회 문제가 해결 되었습니다.
하지만 어떻게이 데이터 채울 수 있습니다.
>> 네, 하 고 복제본을 사용 하 여
최신 상태로 유지 해야 합니까?
어떤 것은 권위?
>>를 수정 합니다. 이중 권리
이중 권한의 좋다고 합니다.
예를 들어 발생 한 경우
실패 하면 다른 작업이 성공 하면 오른쪽?
피드 변경 하면 그 결정적 뵈요
계속 오면 변경의 추적 합니다.
오류 복구를 해야 하므로 수평 확장 해야 합니다.
예를 들어, 상상할 수 있는
많은 것에 무슨 의미가 알고
수 작업 부하 분산에입니다.
이 최소 채권 필드 API를 변경 합니다.
그래? 파티션 키의 범위를 보면 그렇게
이 작동 하는 방법이 있는
파티션 키의 범위를 실제 직접 액세스
변경 내용을 가져올 수 있습니다.
다 분할 하지 독립적으로.
이 아름다움은, 예를 들어,
내가 여러 작업 자가 throw 할 수 있습니다.
에 고에 유용한, 설정 수 있습니까
및 제공 되는 변경 내용을 모두 방전 합니다.
여기에 사용할 수 있는 코드는 궁극적으로
기본적으로 단일 불합리 문서 이라고 생각 합니다.

Russian: 
Поиск ключа секции проблема решена.
Но как заполнить эти данные?
>> Да и использование клонирования
необходимо ли обновлять это?
Какой из них является официальным источником информации?
>> Исправления. Двойные права
зол двойной права.
Например, что случится, если один
завершается неудачей, другой успешно, право?
Изменение канала дает, детерминированной надеюсь
хранить список изменений, как они бывают.
Поэтому нужно аварийного восстановления необходимо масштабировать.
Например, можно нарисовать
Какой смысл множество знает на него,
они могут сделать Балансировка нагрузки, что подобные.
Так что это bare облигации изменить поле API.
Правильно? Таким образом, если взглянуть на раздел диапазонов ключей,
способ работы это, что у вас есть
Фактические прямой доступ к диапазоны ключей раздела
и вы можете получить изменения
независимо от соответствующих разделов.
Красота этого является, например,
Я может выдать несколько работников
на нем и это можно включить в parlor,
и сток все изменения, которые могут быть.
В конечном счете код, который работает здесь
по сути одного абсурдными документа, на мой взгляд.

Czech: 
je oddíl vyhledávací klíče problém vyřešen.
Ale jak se naplní tato data?
>> Ano a pomocí klonování,
je nutné průběžně to?
Která z nich je autoritativní zdroj?
>> Opravte. Dvojité práva
evils dvojité práva.
Jako co se stane, pokud
selže, druhý úspěšný, doprava?
Změna krmiva vám tento deterministický naděje na
udržení přehledu o změny při jejich obdržení.
Tak máte obnovení po selhání, mají měřítko out.
Například můžete nakreslit
spoustu ví, jaké dobré ji,
můžete provést tyto věci tohoto druhu Vyrovnávání zatížení.
Tak to je úplné dluhopisů změnit pole rozhraní API.
Doprava? Ano, pokud se podíváte na klíčové oblasti oddílu,
je způsob, jakým to funguje, že máte
skutečné přímý přístup k oblasti klíče oddílu
a můžete je načíst změny
od těch, které oddíly nezávisle.
Tato výhoda je nyní, například
I lze vyvolat více pracovníků
na ní a lze to zapnout v parlor,
a vyprázdnit všechny změny, které se vyskytují v.
Nakonec je kód, který zde funguje
v podstatě jediné absurd dokument, který myslím.

Chinese: 
分区键查找问题得到解决。
但如何填充这些数据呢？
>> 是，并使用克隆，
是否有将此时间保持最新的？
哪一项是权威来源？
>> 更正。双的权利，
双权利的 evils。
例如如果一个怎么样
失败，另成功，右？
更改数据源提供的确定性与希望
因为他们进来，保持跟踪的更改。
因此必须在其故障恢复，必须向外的扩展。
例如，如果您可以绘制
多个眼，知道有什么好处
他们可以执行负载平衡，等等。
因此，这是裸机债券更改字段 API。
对吧？因此，如果您看一下分区键范围
其工作原理是您必须
实际直接访问的分区键范围
您可以检索更改
从这些分区独立。
好处就是现在，例如，
我可能会引发多个工作人员
它和我在 parlor，可以关闭此
并释放所有的更改。
最终，这里的工作方式的代码是
实质上是一个荒谬文档我认为。

English: 
the partition key look-up problem is solved.
But how do you populate this data?
>> Yeah, and using a clone,
do I have to keep this up to date?
Which one's the authoritative source?
>> Correct. Double rights,
the evils of double rights.
Like what happens if one
fails, the other succeeds, right?
Change feed gives you that deterministic hope to
keep track of changes as they come in.
So, you have failure recovery, you have scale out.
For example, if you can draw a
bunch of what good knows at it,
they can do load balancing, things of that nature.
So this is the bare bonds change field API.
Right? So if you look at partition key ranges,
the way this works is you have
actual direct access to the ranges of partition keys,
and you can retrieve changes
from those partitions independently.
The beauty of this is now, for example,
I can throw multiple workers
on it and I can turn this in parlor,
and drain all of the changes that come in.
Ultimately, the code that works here is
essentially a single absurd document I think.

French: 
le problème de recherche de clé de partition est résolu.
Mais la façon dont vous remplissez ces données ?
>> Oui et à l’aide d’un clone,
faut-il que cette mise à jour ?
Quelle est la source faisant autorité ?
>> À corriger. Droits de doubles,
le mal des doubles droits.
Comme ce qui se passe si un
tombe en panne, l’autre en cas de réussite, droite
Flux de modification vous donne Cet espoir déterministe à
conserver le suivi des modifications lorsqu’elles se.
Ainsi, vous avez la récupération après une panne, vous avez la mise à l’échelle.
Par exemple, si vous pouvez dessiner un
ensemble de sait de quoi
ils peuvent faire équilibrage de charge, les éléments de cette nature.
Donc c’est les obligations sur matériel vierge modifier champ API.
Oui ? Par conséquent, si vous regardez les plages de clés de partition,
la façon dont cela fonctionne est que vous avez
réel accès direct aux plages de clés,
et vous pouvez récupérer les modifications
indépendamment de ces partitions.
La beauté de ce est maintenant, par exemple,
Je peux lever plusieurs travailleurs
dessus et je peux désactiver cette option dans silencieux dans un institut,
et décharger toutes les modifications qui interviennent.
Enfin, le code fonctionne ici est
essentiellement un seul source de mauvaises document que je pense.

Italian: 
è stato risolto il problema di ricerca chiave di partizione.
Ma come inserire questi dati?
>> Sì e l'utilizzo di un duplicato,
è necessario tenere presente questo aggiornato?
Quale è la fonte autorevole?
>> Correggere. Diritti di Double
Mali dei diritti double.
Ad esempio cosa succede se uno
ha esito negativo, l'altro ha esito positivo, a destra?
Modifica feed consente che spero deterministica a
tenere traccia delle modifiche man mano che arrivano.
Pertanto, si avrà operazioni di ripristino, si dispone di scalabilità.
Se, ad esempio, è possibile disegnare un
serie di sa qual è l'utilità
è possibile eseguire il bilanciamento del carico, elementi di tale natura.
In questo modo le obbligazioni bare modificare campo API.
Ok? In tal caso, se si osserva intervalli di chiavi di partizione,
il funzionamento è che è
effettivo accesso diretto agli intervalli di chiavi di partizione,
ed è possibile recuperare le modifiche
le partizioni in modo indipendente da quelli.
Il vantaggio è, ad esempio,
È possibile generare più lavoratori
su di esso ed è possibile tradurre ciò in parlor,
e svuotare tutte le modifiche che possono essere.
In definitiva, il codice che funziona in questo caso è
essenzialmente un documento unico di assurde che credo.

German: 
Partition ist Schlüssel Suche gelöst.
Aber wie Sie diese Daten auffüllen?
>> Ja, und verwenden Sie einen Klon
müssen diese Stand?
Die autorisierende Quelle ist?
>> Korrigieren. Doppelte Rechte
die Übel double Rechte.
Was geschieht, wenn ein
fehlschlägt, erfolgreich anderen, richtig?
Änderung Feed gibt deterministische Hoffnung
Verfolgen der Änderungen bei Eingang.
Sie also Wiederherstellung, Ihnen skalieren.
Angenommen, Sie ziehen eine
Menge, was er weiß
Führen sie einen Lastenausgleich, Dinge, die Natur.
Also ändern bare Rentenwerte Feld API.
Richting? So betrachten Sie Schlüsselbereiche Partition
diese Arbeitsweise ist Sie
tatsächliche direkten Zugriff auf die Bereiche der Partitionsschlüssel
und Änderung abrufen
unabhängig von den Partitionen.
Der Vorteil dieser ist zum Beispiel,
Mehrere Arbeitskräfte können ausgelöst werden.
auf und ich kann im Wohnzimmer,
und alle Änderungen kommen.
Schließlich ist der Code, der hier
im Wesentlichen eine absurd Unterlage, die ich denke.

Polish: 
Wyszukiwanie klucza partycji problem ten został rozwiązany.
Ale jak należy wypełnić te dane?
>> tak i za pomocą klon,
należy mieć to na bieżąco?
Który jest autorytatywnym źródłem?
>> Poprawne. Podwójne prawa,
Zła podwójne prawa.
Jak to, co się stanie, jeśli jeden
kończy się niepowodzeniem, drugi zakończy się powodzeniem, prawo?
Zmiana daje Państwu tej firmy Deterministic Networks mamy nadzieję, że
Śledzenie pracy przetwarzał.
Tak, masz odzyskiwanie po awarii, masz skalowania.
Na przykład, jeśli można rysować
masa co dobrego wie o nim,
mogą je mieć Równoważenie obciążenia, rzeczy tego rodzaju.
Więc jest to bare obligacji zmienić pole interfejsu API.
Prawo? Tak, jeśli spojrzeć na partycji klucz zakresów
sposób, w jaki działa to jest, że masz
rzeczywiste bezpośredni dostęp do zakresów kluczy partycji
można pobrać zmiany
od tych partycji niezależnie od siebie.
Piękno tego jest teraz, na przykład
Można rzucić wielu pracowników
na nim i można włączyć to w salonie,
i wszystkie zmiany, które są w drenażu.
Ostatecznie jest kod, który działa w tym miejscu
zasadniczo jednym absurdalnym dokumencie myślę.

Japanese: 
なり、ソースからすべての変更は、
変換先に適用します。
あった場合、たとえば
「Azure 関数」または「スパーク ストリーミング」を使用してください。
いくつかのより高いレベルのプリミティブ
本質的にするだけを書く必要
ラッパー コードのすべてのないループの 1 つです。
>> が問題になる可能性のある私にではない、
ループ何百万もあるでしょうか。
>> これの長所は 1 回です。
読み取りは、権利よりも安価です。
この作業を 1 回だけ実行していると
構成されたデータを作成したら、
という事実は、効率的な複数の
その費用の支払を行います。
ゲームを取得する場合、これを表示し、
独自の ID でゲームを取得しているだけで
ですから、別のより複雑な例を見る
これは非常に一般的で、
時系列データでは、適切な選択でしょうか。
問題か
課題がありますが、自然なキーがありません。

Polish: 
Który przechodzi i przyjmuje wszystkie zmiany z tego źródła
i stosuje go do miejsca docelowego.
Jeśli, na przykład
przy użyciu "Azure funkcji" lub "Spark strumieniowych",
Niektóre z wyższych poziomów podstawowych,
zasadniczo po prostu musisz napisać, że
jeden dla pętli bez cały kod otoki.
>> Czy istnieje obawa, że I może być w
dla pętli, która ma miliony?
>> Piękno to jest to jeden raz.
Tak więc odczyty są tańsze niż prawa.
I robisz tej pracy tylko raz
a Skoro masz dane, gotowane,
fakt, że odczytuje są efektywne więcej niż
pokrywa koszty.
I to pokazuje, kiedy otrzymujesz gier,
dopiero zaczynasz grę przez własny identyfikator.
Tak więc, jeśli spojrzeć na inny przykład bardziej skomplikowanych,
i jest to bardzo popularny,
Czas serii danych, to prawo?
A problem lub
wyzwaniem jest to naturalne klucz nie istnieje.

Chinese: 
時候，並會將來源的所有變更
並將其套用到目的地。
如果您，例如
使用"Azure 函式 」 或 「 電花術資料流 」，
某些較高的層級基本型別，
基本上你只需要撰寫，
一個 for 迴圈，而不需所有的包裝函式程式碼。
>> 是有可能在的考量
有數以百萬計的迴圈？
>> 它的優點是它一次。
因此，讀取成本較低權限比。
和您進行這項工作一次，
並可一次，價錢的資料
讀取的事實會有效率多個
債券的成本。
這會顯示當您取得遊戲，以及
只會收到自己 id 的遊戲
因此，如果您要查看另一個更複雜的範例，
而這也是很普遍，
它是時間序列資料權限？
而問題或
有的挑戰是沒有自然索引鍵。

Czech: 
Který přechází a přebírá všechny změny ze zdroje,
a vztahuje se k cíli.
Pokud jste například pracovali
pomocí "Funkce Azure" nebo "Spark vysílání",
Některé vyšší úrovně primitiv
v podstatě stejně musíte zapsat
jeden pro smyčku bez kódu.
>> Se obavy, že možná I v
pro smyčka, která má miliony?
>> Je výhodou je, že je jednou.
Ano jsou levnější než práva čtení.
A děláte tuto práci právě jednou
a Jakmile máte data vařené
skutečnost, že čte jsou efektivní více než
platí pro náklady.
A to ukazuje, kdy je získání hry,
stačí vám hru ve své vlastní ID.
Takže pokud se podíváte na další složitější příklad,
a to je velmi obvyklé.
Časové řady je pravý?
A problém nebo
Zde se, že žádný přirozený klíč.

Portuguese: 
Que vai e leva todas as alterações de fonte,
e o aplica ao destino.
Se você fosse, por exemplo
usando "Azure funções" ou "Spark fluxo",
dentre os primitivos de nível mais altos,
essencialmente você terá de escrever esse
um loop sem todo o código wrapper.
>> É uma preocupação que posso estar em um
loop for que possui milhões?
>> A beleza dele é uma vez.
Portanto, as leituras são mais baratas do que direitos.
E você está fazendo isso funcionar exatamente uma vez
e, uma vez que os dados de algo
o fato de que lê são eficientes mais de
paga por esse custo.
E isso mostra quando você obter jogo
Você receberá apenas um jogo por sua própria identificação.
Portanto, se você olhar outro exemplo mais complicado,
e isso é muito comum,
dados de série de tempo, é certo?
E o problema ou
lá, o desafio não é que não existe nenhuma chave natural.

Italian: 
Che va e accetta tutte le modifiche dall'origine,
e lo applica alla destinazione.
Se, ad esempio
utilizzo di "funzioni Azure" o "scintilla" di flusso
alcune delle primitive di livello superiore,
essenzialmente solo è necessario scrivere che
uno per ciclo senza tutto il codice wrapper.
>> Si è verificato un problema che la sensazione di essere in un
ciclo for che include milioni?
>> Il vantaggio è una sola volta.
Quindi, legge sono meno costosi rispetto dei diritti.
E si effettua questa operazione una sola volta,
e dopo avere i dati cotti
il fatto che legge sono efficienti più di
Paga il costo.
E verranno visualizzati quando si guida giochi,
si otterrà solo un gioco per il proprio ID.
Pertanto, se si esamina un altro esempio più complesso,
e questo è molto comune,
dati di serie temporali, la soluzione migliore?
Il problema e o
la sfida non vi è che nessuna chiave naturale.

Spanish: 
Que va y toma todos los cambios desde el origen
y se aplica al destino.
Si fuera, por ejemplo
con "Funciones de Azure" o "Transmisión de chispa",
algunas de las primitivas de nivel superior,
básicamente sólo tendrá escribir
uno para bucle sin todo el código del contenedor.
>> Allí es un problema que podría estar en un
¿bucle for que tiene millones?
>> La belleza de la misma es una vez.
Por lo tanto, las lecturas son más baratas que los derechos.
Y realiza exactamente una vez, este trabajo
y una vez que tenga los datos cocidos
el hecho de que lee son eficaces más de
paga por dicho costo.
Y esto muestra cuando se siente del juego,
sólo está obteniendo un juego por su propio identificador.
Por tanto, si se mira otro ejemplo más complicado:
y esto es muy común,
¿son datos de series temporales, derecho?
Y el problema o
allí el desafío es que no hay ninguna clave natural.

Turkish: 
Gider ve tüm değişiklikleri kaynak alır,
ve hedef için geçerlidir.
Örneğin alınmış
"Azure işlevler" veya "Spark akış" kullanma
Bazı üst düzey ilkel,
Aslında, sadece, yazmak gerekir
bir for döngüsü tüm sarmalayıcı kodları olmadan.
>> İçinde olabilecek önemli olduğu bir
for döngüsü, milyonlarca var mı?
>> Bir kez olan güzelliğinin olur.
Bu nedenle, okuma haklarını ucuz.
Ve bu iş tam bir kez yaptığınız işe,
ve hazırlanan veri sahip olduktan sonra
okur olgu verimli birden fazla
Bu maliyet için öder.
Ve bu, ne zaman, alma oyun gösterir,
yalnızca bir oyun kendi kimliğine göre almakta olduğunuz
Bunu, daha karmaşık bir başka örneğe bakarsanız,
ve bu çok yaygın olarak kullanılır,
Zaman serisi veri sağ mı?
Ve sorun veya
orada doğal anahtarı yok iştir.

English: 
That goes and takes all of the changes from the source,
and applies it to the destination.
If you were, for example
using "Azure Functions" or "Spark Streaming",
some of the higher level primitives,
essentially you'll just have to write that
one for loop without all of the wrapper code.
>> Is there a concern that I might be in a
for loop that has millions?
>> The beauty of it is it's once.
So, reads are cheaper than rights.
And you're doing this work exactly once,
and once you have the data cooked up,
the fact that reads are efficient more than
pays for that cost.
And this shows you when you getting game,
you're just getting a game by its own ID.
So, if you look at another more complicated example,
and this is very common,
it's Time-series data, right?
And the problem or
the challenge there is there is no natural key.

Chinese: 
它会和源中的数据采用的所有更改
并将其应用到的目标。
如果您是
使用"Azure 函数"或"流触发"，
一些高级别基元
实质上是您不得不这样写
一个用于所有包装代码的循环。
>> 有一个中可能存在的问题
有数以百万计的循环吗？
>> 它的优点在于它是一次。
因此，读取的权限比便宜。
和您在一次，做这种工作
和之后，向上修正的数据
读取的事实是高效多
支付的成本。
这显示您遇到了游戏
您只收到了游戏通过它自己的 id。
因此，如果您看一下另一种更复杂的示例中，
这也是很常见，
它是时间序列数据，正确？
并解决问题或
有难题是没有自然键。

German: 
Das geht und nimmt alle Änderungen von der Quelle
für das Ziel.
Wenn beispielsweise wurden
Mithilfe von "Azure Funktionen" oder "Spark Streaming"
Einige der höheren Ebene primitive
im Wesentlichen müssen Sie zu schreiben
eine for-Schleife, ohne den Code.
>> Gibt es ein Problem im möglicherweise ein
for-Schleife, die Millionen?
>> Die Schönheit ist es einmal.
Lesevorgänge sind günstiger als Rechte.
Und Sie dabei genau einmal tun
und haben Sie die Daten gekocht
die liest sind effiziente über
Diese Kosten trägt.
Und zeigt Sie beim Spiel
Sie bekommen nur eine Spiel durch eine eigene ID
Wenn also ein anderes kompliziertere Beispiel betrachten,
und das ist nicht ungewöhnlich,
Es stimmt Zeitreihen-Daten?
Das Problem oder
Die Herausforderung ist, dass kein natürlicher Schlüssel vorhanden ist.

Korean: 
들어가고 소스에서 변경 내용을 사용 하는
대상에 적용 합니다.
예를 들어가
"스파크 스트리밍" 또는 "Azure 함수"를 사용 하 여
더 높은 수준의 기본 형식 중 일부를
기본적으로 작성을 해야만
하나는 래퍼 코드 없는 루프입니다.
>> 거기에 빠질 것을 염려 한
루프에 있는 수백만?
>>의 장점은 한 번 이기입니다.
따라서 읽기는 권한 보다 더 저렴 합니다.
정확히 한 번만이 작업을 수행 하 고 있는 고
있으면, cooked 데이터 및
사실 읽는 것은 효율적이 이상
그 비용을 지불 합니다.
때 가져오기 하면 게임에 표시이 고
단지 게임 자체 id 있 잖
따라서, 다른 더 복잡 한 예를 보면
이것은 매우 일반적인 작업 이므로
시계열 데이터를 도달할 때?
고 문제 또는
기본 키가 존재 하는 문제는

Russian: 
Который проходит и принимает все изменения из источника,
и применяет его к месту назначения.
Если, к примеру
с помощью «Azure функции» или «Потоковой передачи Spark»,
Некоторые из более высокого уровня примитивы,
по существу вы просто придется написать
один цикл не весь код оболочки.
>> Существует проблема, я может быть в
цикл for с миллионам?
>> Красота – это один раз.
Итак операции чтения дешевле, чем права.
И вы делаете это работать только один раз
и при наличии данных cooked
тот факт, что читает эффективны более
оплачивает затрат.
И это показывает, когда вы Начало игры
точно так же для получения игры, собственный идентификатор.
Итак, если взглянуть на другой более сложный пример:
и это очень часто
Это временные ряды данных, право?
И проблема или
существует проблема в том, что отсутствует естественный ключ.

French: 
Qui va et accepte toutes les modifications de la source,
et l’applique à la destination.
Si vous avez, par exemple
à l’aide de « Fonctions Azure » ou « Étincelle en flux continu »,
Parmi les primitives de niveau supérieurs,
essentiellement vous reste plus qu’à écrire que
une boucle for sans tout le code du wrapper.
>> Existe-t-il un problème depuis un
boucle for qui a des millions ?
>> La beauté de ce dernier est qu’une seule fois.
Par conséquent, les lectures sont moins chers que les droits.
Et vous faites ce travail une seule fois,
et une fois que vous avez les données cuites
le fait que les lectures sont efficaces plus de
pays de ce coût.
Et vous indique quand vous lors de l’obtention de jeu,
vous recevez simplement un jeu par son propre code.
Par conséquent, si vous regardez un autre exemple plus complexe,
et cela est très courant,
données de la série chronologique, il convient ?
Et le problème ou
le défi il est qu’il n’y a pas de clé naturelle.

Japanese: 
つまり、することは避けて、キーですとして時間を使用
自然につながること
アプリケーション内でのホット スポットです。
したがって、タイム シリーズのデータを処理するか。
ここでは、基本的には、これ
さまざまな値を持つものが発見されます。
ここでは、[リポジトリの索引を見るため
何行う上でここでは、
私のパーティション キーとしてのセンサーの ID を使用して基本的には、です。
センサーの数値があるかどうかは、これが何を意味し、
常に、全体のスループットを使用することができます。
すべてを同時に書き込みを続けることができます。
裏側の面では、クエリを行う場合
これらのパーティションのすべての読み取りする必要があります。
>> 権限。
>> はさぁ、インデックスがあるためですが、
各パーティション内で時間の範囲の情報。
ここでは、変更のフィードの同じ考えを拡張するには
何かの操作を行いますが、

Czech: 
I střední, je tempting použít jako klíče ale čas
to přirozeně vede k
aktivní body v rámci aplikace.
Tak jak je zpracovávat data časových řad?
A zde, v podstatě trik na
je najít něco, co má široký rozsah hodnot.
Nyní, protože vypadají Moje Repo
Co to bude zde
je že v podstatě používám snímače ID jako můj klíč oddílu.
A to znamená, zda mám několik čidel,
můžete nadále používat úplnou propustnost
a všechny mohou pokračovat zapisovat současně.
Straně flip je, pokud máte dotazy,
je třeba číst ve všech těchto oddílů.
>> Doprava.
>>, Ale to nevadí protože index
rozsah informací čas v rámci každého oddílu.
Nyní rozšířit stejné myšlenky, změna krmiva,
v některých případech co chcete udělat se

French: 
Par exemple, il est tentant d’utiliser l’heure comme la clé mais
Ceci nous mène naturellement à
zones réactives dans votre application.
Par conséquent, comment gérer les données de la série chronologique ?
Et là, pour l’essentiel, l’astuce pour
Il recherche un élément qui a un large éventail de valeurs.
Maintenant, puisque je regarde mon mis en pension,
ce que je fais ici,
est que j’utilise essentiellement des ID de capteur en tant que ma clé de partition.
Et cela signifie si je dispose d’un certain nombre de capteurs,
ils peuvent continuer à utiliser le débit total,
et ils peuvent continuer à écrire en même temps.
L’inconvénient est lorsque vous effectuez des requêtes,
Vous seriez obligé de le lire sur l’ensemble de ces partitions.
>> Droite.
>>, Mais c’est OK, car la présence d’un index
des informations de plage de temps dans chaque partition.
Désormais, d’étendre l’idée même d’alimentation de la modification,
parfois que voulez-vous faire est,

Chinese: 
我的意思是，它很容易作为密钥，但使用时间
这很自然地产生了
在您的应用程序中的热点。
因此，如何处理时间系列数据？
和这里，实质上，这一轮到
其发现有范围广泛的值的东西。
现在，因为我看我 Repo，
我到底这里，
是我为我的分区键实质上使用传感器 ID。
这意味着我有大量的传感器，
他们可以继续使用的完整的吞吐量，
然后他们可以全部继续写入一次。
另一面是时所做的查询，
您必须读取所有这些分区。
>> 的权限。
>>，但这是好了，因为我有一个索引
在每个分区内的时间范围信息。
现在，若要扩展的更改源相同的思想
有时候要做，

Spanish: 
O sea, es tentador utilizar tiempo como la clave, pero
Esto conduce naturalmente a
puntos calientes dentro de la aplicación.
Así que, ¿cómo maneja datos de series temporales?
Y aquí, en esencia, el truco para
es encontrar algo que tiene una amplia gama de valores.
Ahora, ya que se miran mi Repo
lo que hago este caso,
es que esencialmente estoy usando ID del sensor como mi clave de partición.
Y lo que esto significa es que si tiene un número de sensores,
puede seguir utilizando el rendimiento total,
y puede continuar a escribir al mismo tiempo.
El lado amargo es cuando está realizando consultas,
tendría que leerlo en todas estas particiones.
>> Derecho.
>>, Pero no importa porque tengo un índice
en la información de intervalo de tiempo dentro de cada partición.
Ahora, para extender la misma idea de cambiar fuente,
a veces, ¿qué desea hacer es,

English: 
I mean, it's tempting to use time as the key but
that naturally leads to
hot spots within your application.
So, how do you handle Time-series data?
And here, essentially, the trick to
it is finding something that has a wide range of values.
Now, since I look at my Repo,
what I'm doing over here,
is I'm essentially using sensor ID as my partition key.
And what this means is if I have a number of sensors,
they can continue to use the full throughput,
and they can all continue to write at the same time.
The flip side is when you're doing queries,
you would have to read it across all of these partitions.
>> Right.
>> But that's okay because I have an index
on the time range information within each partition.
Now, to extend the same idea of change feed,
sometimes what do you want to do is,

Polish: 
To znaczy, to kuszące, aby wykorzystać czas jako klawisza poza
to naturalnie prowadzi do
Popularne miejsca w obrębie aplikacji.
Tak jak obsługiwać szeregu czasowego danych?
I tutaj, zasadniczo, lewę do
jest znalezienie coś, co ma szeroki zakres wartości.
Teraz, skoro patrzę na Moje "repo",
co robię tutaj,
jest to zasadniczo używam ID czujnika jako mój klucz partycji.
I oznacza to, czy liczba czujników,
one można nadal używać pełnej przepustowości,
i one wszystkie nadal pisać w tym samym czasie.
Z drugiej strony jest podczas wykonywania kwerendy,
trzeba ją przeczytać we wszystkich tych partycji.
>> Do prawej.
>>, Ale nie szkodzi, ponieważ mam indeksu
na informacje dotyczące zakresów czasu w ramach każdej partycji.
Teraz, aby rozszerzyć ten sam pomysł zmiany paszy,
Czasami to, co chcesz zrobić,

Russian: 
Я имею в виду, выглядит очень заманчиво для использования в качестве ключа но время
Это, естественно, ведет к
гиперобласти в приложении.
Таким образом как обрабатывать временных рядов данных?
И здесь, по сути, чтобы
он находит то, что имеет широкий диапазон значений.
Теперь так как просмотреть Мои Repo
что я делаю здесь,
— Это идентификатор датчика по существу используя как ключ раздела.
А это означает наличие нескольких датчиков,
они могут продолжать использовать полную пропускную способность,
и они могут продолжать производить запись в то же время.
С другой стороны, при выполнении запросов,
необходимо прочитать для всех разделов.
>> Право.
>>, Но это неважно, поскольку индекс
в сведения о диапазоне времени в каждой секции.
Теперь, чтобы расширить эту же идею изменения канала,
Иногда то, что вы хотите сделать,

Turkish: 
Ben ortalama, bu kez anahtar ancak kullanmaya tempting
doğal olarak yol açar
etkin noktalar uygulamanız içinde.
Bu nedenle, nasıl, ele zaman serisi veri?
Ve burada, aslında, eli için
çok çeşitli değerlere sahip bir şey buluyor.
Şimdi, benim Repo at yapmam bu yana
ne burada yaptığımı,
Bölüm anahtarımı aslında algılayıcı kimliği kullanıyorum olduğunu.
Ve ne bu algılayıcılar çok sayıda sahip olduğu anlamına gelir,
Bunlar tam verim kullanmaya devam edebilirsiniz,
ve bunların tümünü aynı anda yazmaya devam edebilirsiniz.
Sorgular yapılırken Çevir yan ise,
Tüm bu bölümleri okumak zorunda kalacaktır.
>> Sağ.
>> Ancak bu sorun olmayacaktır dizin çünkü
zaman aralığı hakkında bilgi her bölüm içinde.
Şimdi, aynı değişikliği besleme fikrini genişletmek için
Bazı durumlarda ne yapmasını istiyorsunuz değil,

Chinese: 
我的意思，很容易作為索引鍵但的時間
自然通往
在應用程式內的作用點。
因此，您該如何處理時間數列資料？
接下來，基本上，這一輪到
它會尋找已大範圍的值的項目。
現在，因為我看看我的 Repo，
我在這裡幹，
是我為我的磁碟分割金鑰基本上使用感應器的識別碼。
這表示如果我有許多感應器和
它們可以繼續使用完整的輸送量，
和它們所有書寫可以繼續在同一時間。
翻轉側邊是當您進行查詢，
您必須為所有的這些磁碟分割。
>> 權限。
>> 但是沒關係，因為我已經索引
在每個磁碟分割內的時間範圍資訊。
現在，來延伸相同概念的變更摘要
有時執行想要執行，

Portuguese: 
Quer dizer, é tentador usar tempo como o principal, mas
Naturalmente, isso leva a
pontos de acesso dentro do seu aplicativo.
Então, como você lida com dados de séries de tempo?
E aqui, basicamente, o truque para
ele é encontrar algo que tem uma ampla variedade de valores.
Agora, já que eu examinar meu Repo
o que estou fazendo aqui,
é que essencialmente estou usando sensor ID como a chave da partição.
E o que isso significa se tenho um número de sensores,
eles podem continuar a usar a taxa de transferência total
e eles podem continuar a gravar ao mesmo tempo.
O outro lado é quando você está fazendo consultas,
Você precisa lê-la em todas as partições.
>> À direita.
>>, Mas que é okey porque tenho um índice
as informações de intervalo de tempo em cada partição.
Agora, para estender a mesma ideia do feed de alteração
às vezes, o que você deseja fazer é,

Korean: 
내 말은, 이기는 하지만 그 핵심으로 시간을 사용 하 고 싶어
자연스럽 게 까지로 하는
응용 프로그램 내에서 핫스폿
따라서 시계열 데이터를 어떻게 처리 합니까?
여기에서는 기본적으로 트릭과
발견 하는 다양 한 범위의 값을 가진 것입니다.
지금은 내 Repo 살펴보기 때문
무엇
기본적으로 센서 ID 내 파티션 키로 사용 됩니다.
이것이 의미 하는 다양 한 센서의 경우 감염 되었다는 사실을 고
전체 처리량을 사용 할 수 있습니다.
고 수 모두 동시에 쓰기를 계속 합니다.
쿼리를 수행할 때 긍 적 적인 측면은
파티션의 모든 읽을 것입니다.
>> 권한입니다.
>> 괜찮습니다 인덱스 때문에
각 파티션 내에서 시간 범위 정보입니다.
지금은 변경 피드 같은 개념을 확장 하
가끔 원하는 작업을 수행 하는,

German: 
Ich meine, ist es verlockend zu verwenden als die-Taste gedrückt, und
Dies führt natürlich zu
Hotspots in der Anwendung.
So, wie Sie Zeitreihen-Daten behandeln?
Und hier im Wesentlichen schreiben
etwas findet, die Werte hat.
Jetzt, da ich meine Repo betrachten,
Was mache ich hier über,
ist im Wesentlichen Sensor-ID als meine Partitionsschlüssel benutze.
Und dies bedeutet habe Sensoren
Sie können weiterhin den vollständigen Durchsatz verwenden,
und sie können alle gleichzeitig schreiben.
Die Kehrseite ist Wenn Sie Abfragen durchführen
Sie müssten für alle diese Partitionen lesen.
>> Recht.
>>, Aber das ist normal, da ich einen Index
Mal Bereich Informationen in jeder Partition.
Jetzt dasselbe ändern Feed erweitern,
Manchmal Was möchten Sie tun wird

Italian: 
Intendo dire, può essere tentati di utilizzare la chiave ma
Ciò porta naturalmente a
aree sensibili all'interno dell'applicazione.
In questo caso, come si gestiscono dati di serie temporali?
Di seguito, in pratica, la soluzione per
la ricerca di qualcosa che offre una vasta gamma di valori.
Ora, poiché è osservare il mio Repo,
procedura che qui,
è che essenzialmente si utilizza sensore ID come la chiave di partizione.
E ciò significa che se si dispone di un numero di sensori,
è possibile continuare a utilizzare il throughput completo,
e tutti possono continuare a scrivere contemporaneamente.
Rovescio è quando si effettua una query,
è necessario leggerlo tra tutte le partizioni.
>> A destra.
>>, Ma poiché dispone di un indice
nelle informazioni sull'intervallo di tempo all'interno di ogni partizione.
Ora, per estendere lo stesso concetto dei mangimi di modifica,
Talvolta ciò che si desidera eseguire è,

Czech: 
máte data, která je nezpracovaná data.
A pokud chcete využít nezpracovaná data a
Řekněme, že jste to vidět v Azure portálu.
Pokud máte data, která je uspořádán do minuty,
a pak máte data, která je vrácena
a je například souhrnné agregace nebo hodiny
a pak den a tak dále.
Výhodou tohoto je, péče o
vysoká přesnost v rámci nedávné časová okna
ale pouze záleží
shrnutí na delší čas systému windows.
A je možné vytvořit, přesné stejné
Agregace času systémem okno Změna kanálu.
>>, Kde je toto úložiště
tak mohou uživatelé přejít a podívejte se na tyto vzorky?
>> Tak to je GitHub,
Pokud přejdete, se podívejte na GitHub pod our.Net vzorky.
>>, Máme github.com/azure.
A v rámci Azure documentDB.net,
máte k dispozici vzorky a doslova
vše máte právo zde máte,
je k dispozici, takže všechny
zdrojový kód jsme jsme nic skrýt.

French: 
vous avez des données des données brutes.
Et si vous souhaitez prendre les données brutes et,
Supposons que vous avez déjà étudié cela dans Azure portal ainsi.
Si vous avez des données qui sont organisées par minute,
et vous avez les données reportées,
et il est, par exemple, un résumé de regroupement ou d’une heure
puis jour et ainsi de suite.
Et l’avantage de cette vous soins sur
la grande précision dans vos fenêtres de temps récente,
mais vous vous souciez uniquement
cumulées à la fois plus de temps que windows.
Et vous pouvez en créer que même exacte
agrégation de fenêtre de temps à l’aide de la modification d’alimentation.
>> Où est ce référentiel
donc personnes peut accéder et consulter tous les exemples de ces ?
>>, Il s’agit donc de GitHub,
Si vous allez examinez GitHub sous our.Net exemples.
>>, Nous avons github.com/azure.
Et sous Azure, documentDB.net,
vous avez des échantillons et littéralement
tout ce dont vous avez droit que vous avez, ici
Il est plus disponible, donc tous les
la source de code nous nous masquer rien.

Italian: 
si dispone di dati che rappresenta i dati non elaborati.
E se si desidera richiedere i dati non elaborati e,
Si supponga di che aver visto questo nel portale anche Azure.
Se si dispongono di dati che sono organizzati per minuto,
e quindi si dispongono di dati che viene eseguito il rollback
ed è un aggregato riepilogativa o l'ora, ad esempio,
quindi giorno e così via.
E il vantaggio di questo è si pone
ad alta precisione all'interno delle finestre di tempo recente,
ma vi interessano soltanto
aggiornamenti cumulativi in windows il tempo più lungo.
Ed è possibile creare esattamente lo stesso
Aggregazione temporale basata su finestre utilizzando Modifica feed.
>> Dove si trova il repository
così gli utenti possono passare e osservare tutti questi esempi?
>> È in GitHub,
Se si passa a dare un'occhiata GitHub in campioni di our.Net.
>>, Sono presenti github.com/azure.
E in Azure, documentDB.net,
Hai esempi e letteralmente
tutto ciò che hai diritto qui è che,
è disponibile, in modo che tutte
l'origine di codice abbiamo nascondere nulla.

Polish: 
masz dane nieprzetworzone dane.
A jeśli chcesz przejąć nieprzetworzone dane i,
Załóżmy, że widziałem to w portalu Azure.
Jeśli masz dane, które są zorganizowane według minut,
a następnie dane, które są rzutowane
i to na przykład podsumowane agregatu lub godzinę
a następnie dzień i tak dalej.
A korzyść z tego jest dbałość o
wysokiej precyzji w ciągu ostatnich przedziałów czasowych,
ale tylko dbają o
rzutowania na dłuższy czas systemu windows.
I można zbudować, który dokładnie takie same
Agregacja oparte na okno czasu przy użyciu zmian w źródle.
>> W przypadku gdy jest to repozytorium
tak osoby mogły przejść i przyjrzyj się tych próbek?
>> Tak to w GitHub,
Jeśli spojrzeć na GitHub w obszarze próbki our.Net go.
>> Więc z github.com/azure.
I pod Azure documentDB.net,
masz już próbki i dosłownie
wszystko mam prawo tutaj masz go,
jest dostępna, więc wszystkie
Kod źródłowy w My możemy nic nie ukryć.

Chinese: 
您的数据是原始数据。
如果想要取得原始数据，
让我们假设您已经看到这在 Azure 的门户。
如果您的数据按分钟、 组织
然后将汇总的数据
例如，是一个汇总的聚合或小时和
然后一天，等等。
这样做的好处是担心
在最近的时间窗口内, 高精度
但您只关心
汇总在更长的时间窗口。
您可以生成精确的相同，并且
使用更改的时间窗口基于聚合馈送。
>> 所在此资料库
因此人们可以转并看一下所有这些样本？
>> 因此，这是在 GitHub，
如果你再看看 GitHub 下 our.Net 样本。
>> 因此，我们有 github.com/azure。
在 Azure，documentDB.net，
你样本和字面意义
是否选中了正确的一切此处您有它，
有什么用，所以所有
我们源代码我们隐藏执行任何操作。

Spanish: 
tiene datos que son datos sin procesar.
Y si desea tomar los datos sin procesar y,
Supongamos que ya lo ha visto en el portal de Azure también.
Si tiene datos que están organizados por minuto,
y, a continuación, se tienen datos que se ha distribuido,
y es un agregado de resumen o la hora, por ejemplo,
y, a continuación, día y así sucesivamente.
Y la ventaja de esto es la atención acerca de
la alta precisión dentro de las ventanas de tiempo reciente,
pero sólo puede ocuparse
resúmenes en las ventanas de tiempo más largo.
Y puede generar exacto igual
fuente de agregación basados en ventanas de tiempo con el cambio.
>> Donde es este repositorio
¿así que la gente puede y mirar todos estos ejemplos?
>> Por lo tanto, esto está en GitHub,
Si va a echar un vistazo GitHub en our.Net ejemplos.
>>, Tenemos github.com/azure.
Y en Azure, documentDB.net,
Tienes ejemplos y literalmente
todo lo que tienes derecho aquí lo tiene,
¿Hay disponible, por lo que todas
el origen de código nos ocultamos nada.

Chinese: 
您必須是未經處理資料的資料。
如果您要取得未經處理的資料，
例如，假設您了解這 Azure 入口網站。
如果您有一分，組織的資料
然後的已縮合的資料
比方說，是合併彙算的彙總或小時
然後天，以此類推。
而的優點是您注意
在您最近使用的時間視窗，高的精確度
但您只在乎
較長的時間 windows 的彙總。
而您可以建置該實際相同
時間視窗架構彙總使用變更摘要。
>> 此儲存機制哪兒去了
因此人可以去查看所有這些範例？
>> 因此，這是 GitHub，
如果您看看 GitHub 下 our.Net 的範例。
>> 因此，我們必須 github.com/azure。
並在 [Azure，documentDB.net，
你的範例和解譯為常值
您選擇了正確的所有項目已經擁有它，裏
是否有可用的因此所有
來源的程式碼我們我們隱藏執行任何動作。

Turkish: 
Ham veriler veri var.
Ve ham veri almak istiyorsanız ve,
Bu Azure Portal'da gördünüz diyelim.
Dakikaya göre düzenlenmiş veriler varsa,
ve sonra toplanan veriler varsa,
ve özetlenen toplama veya saat gibi
ve sonra bir gün ve benzeri.
Ve bu yararı, bakımı hakkında
yüksek hassasiyetli son kez windows içinde
ancak yalnızca ilgilendiğiniz
Toplamalar uzun zaman Windows.
Ve, aynı tam yapı
zaman penceresi tabanlı toplama kullanarak değişiklik besleme.
>> Bu havuzda nerede
Bu nedenle insanların gidin ve Bu örneklerin bak?
>> Böylece, GitHub içinde olan,
bakalım GitHub our.Net örnekleri altında giderseniz.
>> Nedenle, github.com/azure gerekir.
Azure altında ve documentDB.net,
örnekleri var ve tam anlamıyla
sağ var olan her şey Burada, olması gibi
orada, kullanılabilir tüm
Kaynak kodu biz biz bir şey gizleme.

Portuguese: 
Você tem dados que são dados não processados.
E se você deseja levar os dados brutos e,
Digamos que você viu isso no portal Azure.
Se você tiver dados que são organizados por minuto,
e, em seguida, você tem dados que são acumulados,
e é um agregado resumido ou hora, por exemplo,
e, em seguida, dia e assim por diante.
E o benefício disso é cuidado sobre
alta precisão em períodos recentes,
mas você só se preocupa
roll-ups por períodos mais longos.
E você pode criar que exata mesmo
feed de agregação com base em janela de tempo usando alterações.
>> Onde está o repositório
então pessoas podem ir e examinar todos esses exemplos?
>> Assim, isso está no GitHub,
Se você vai dar uma olhada no GitHub em exemplos de our.Net.
>>, Temos github.com/azure.
E sob o Azure, documentDB.net,
Há exemplos e literalmente
tudo o que você tem direito aqui você tem,
há disponível, para que todas as
a fonte de código podemos ocultar nada.

English: 
you have data that is raw data.
And if you want to take the raw data and,
let's say you've seen this in the Azure portal as well.
If you have data that's organized by minute,
and then you have data that's rolled up,
and it's a summarized aggregate or hour for example,
and then day and so on.
And the benefit of this is you care about
the high precision within your recent time windows,
but you only care about
roll-ups at the longer time windows.
And you can build that exact same
time window-based aggregation using change feed.
>> Where is this repository
so people can go and look at all these samples?
>> So, this is in GitHub,
if you go take a look at GitHub under our.Net samples.
>> So, we have github.com/azure.
And under Azure, documentDB.net,
you've got samples and literally
everything you've got right here as you have it,
is there available, so all
the source code we we hide nothing.

Russian: 
имеются данные, исходные данные.
И если вы хотите получить необработанные данные, а,
Предположим, вы уже видели на портал Azure.
Если у вас есть данные, организованные по минутам,
а затем имеются данные, сведенные,
и это Обобщенные статистические или времени например,
а затем день и т. д.
И это преимущество будет заниматься
высокая точность в последнее время windows,
но только волнует
накопительные обновления, устраняющие в окнах больше времени.
И можно строить, точное же
с помощью изменения статистическую оконную время каналов.
>> Где находится этот репозиторий
Таким образом пользователям можно вернуться и посмотрите на эти примеры?
>> Это в GitHub,
Если вы взгляните на GitHub в разделе примеры our.Net.
>> Таким образом у нас есть github.com/azure.
А в Azure documentDB.net,
у вас есть образцы и буквально
все, что у вас есть право здесь у вас есть,
доступен здесь, так что все
исходный код, мы мы ничего не скрыть.

Korean: 
데이터는 원시 데이터를 해야 합니다.
원시 데이터를 사용 하는 경우,
Azure 포털에이 본 경우를 가정해 봅니다.
분으로 구성 된 데이터가 있는 경우
데이터를 겹쳐서 표시 되어 있으면 다음
며 요약된 집계 또는 시간 등
일 고 등.
이 혜택은 보험에 대 한
최근 시간 창 내의 높은 정밀도
가용성만 중요할 하지만
증가 긴 시간 창에서.
하 고 정확 하 게 동일을 만들 수 있습니다.
시간 창 기반 집계 변경을 사용 하 여 공급 합니다.
>>이 저장소는 어디 입니까
따라서 사람들이 이동한 이러한 모든 샘플을 보면 수 있습니까?
>> 따라서에 GitHub, 이것은
이동 our.Net 샘플에서 GitHub 살펴보시기 바랍니다.
>> 따라서 github.com/azure를 해야합니다.
Azure에서 documentDB.net,
샘플을가지고 문자 그대로 하 고
오른쪽가지고 모든 것을 있다면 여기
사용할 수 있는 모든
우리는 소스 코드 아무것도 숨길 우리.

Japanese: 
生データのデータがあります。
生データを取得する場合と、
Azure ポータルを同様に見たときこれを考えてみましょう。
1 分で構成されるデータがある場合
、ロールアップされるデータがあるし、
集計の集計や時間など、
1 日とします。
これの利点は、気を提供して
最近の時間ウィンドウ内で高精度
だけを処理するが、
長いタイム ・ ウィンドウには、重ね合わせ。
同じ正確なを構築することができ、
時間ウィンドウ ベースの集合体の変更を使用してフィードです。
>> がこのリポジトリです。
ので人は移動し、これらすべてのサンプルを見てできますか。
>>、これは、GitHub で
移動する場合を見て GitHub [our.Net のサンプルです。
>> ため、github.com/azure があります。
Azure、documentDB.net、
サンプルがあれば、そのまま
すべての権利があれば、それがあるためここでは
利用可能で、すべて
ソースのコードは何も非表示にします。

German: 
Sie haben Daten Rohdaten.
Und wenn die unformatierten Daten und
Angenommen, das in Azure Portal gesehen haben.
Wenn Sie Daten, die Minute organisiert,
und dann Daten, die zusammengefasst werden,
und es wird eine Zusammenfassung Aggregat oder Stunde
und Tag und so weiter.
Und dies ist kümmern
die Präzision innerhalb der aktuellen Zeitfenster
aber Sie nur
Rollups längere Zeit Windows.
Erstellen, die genau gleich
Windows-basierten Zeitaggregation mit Feeds.
>> Dieses Repository ist
Damit Personen können und diese Beispiele?
>> Ist im GitHub,
Wenn man GitHub unter our.Net Beispiele betrachten.
>>, Wir haben github.com/azure.
Und Azure documentDB.net,
Beispiele haben und
Alles, was Sie Recht haben hier, wie Sie
Gibt es, alle
der Quellcode wir nichts ausgeblendet.

Korean: 
>> 예, 우리가 아무것도 숨길.
고는 물론,
이보다 더 흥미로운 사례로 전체 부분을
경우를 처리 하는 방법
큰 있는 문서, 큰 키.
따라서 다양 한 장단점을 보여 줍니다.
사용할 수 있는 패턴입니다.
물론, 굳이 설명서가 고
이 저장소에도이 외에도 샘플입니다.
>> 얼마나 좋을까 1 시간 이상에 대해 살펴볼 수 있습니다.
훨씬 좋은 정보 및 인양
사용할 수 있는 유용한 리소스
사용 하는 방법을 배울 수 있습니다
Azure Cosmos DB와 그 안에 문서 DB 기능.
체크 아웃 해당 GitHub 저장소에 있는지 확인 하십시오.
모든 샘플을 Irvin
제공 됩니다 것으로 나타났습니다.
하 고 난 훨씬 오늘의 교훈은 Azure에서 금요일.

Portuguese: 
>> Sim, podemos ocultar nada.
E, é claro, existem
casos mais interessantes para todos eles,
como lidar com casos
onde você tem grandes documentos, chaves grandes.
Portanto, ele ilustra várias vantagens e desvantagens,
os padrões que você pode usar.
Obviamente, há uma tonelada de documentação e
amostras além de isso, bem como neste repositório.
>> Gostaria que poderia falar para uma hora ou mais.
Há informações muito grande e muito
excelentes recursos disponíveis para
Você aprenderá a usar
Azure Cosmos DB e os recursos de banco de dados do documento.
E certifique-se de que fazer check-out desse repositório GitHub.
Todas as amostras que Irvin
mostramos estão disponíveis para você.
E eu aprendi muito hoje no Azure sexta-feira.

Italian: 
>> Sì, abbiamo nascondere nulla.
E, naturalmente, esistono
casi più interessanti per tutti i componenti,
modalità di gestione casi
documenti di cui si dispone di grandi dimensioni, chiavi di grandi dimensioni.
In questo caso, illustra i diversi compromessi,
i modelli che è possibile utilizzare.
Naturalmente, non vi è una considerevole quantità di documentazione e
esempi in ogni caso anche in questo repository.
>> Auguro che potremmo parlare per un'ora o più.
È molto grande informazioni e funzionalità
numerose risorse disponibili per
è possibile imparare a utilizzare
Azure Cosmos DB e le sue funzionalità documento DB.
E assicurarsi che si estrae il repository di GitHub.
Tutti gli esempi di Irvin
ha dimostrato sono disponibili.
E imparato molto oggi in Azure venerdì.

Turkish: 
>> Evet, biz bir şey gizleme.
Ve Elbette vardır
Tüm bunlardan daha ilginç çalışmaları,
durumları nasıl ele alınacağını
belgeler, büyük olan, büyük anahtarların.
Bu nedenle, çeşitli bileşim gösterir,
kullanabileceğiniz desenleri.
Kuşkusuz, belgeleri Ço yoktur ve
örnekleri Bunun yanı sıra aynı zamanda bu havuzda.
>> Ben, biz bir saat veya daha fazla konuşabilir istiyor.
Çok iyi bilgi ve çok var.
mükemmel kaynakları için kullanılabilir
nasıl kullanılacağını öğrenmek için
Azure Cosmos DB ve DB belge özellikleri.
Ve bu GitHub depoyu denetlediğinizden emin olun.
Tüm örnekleri bu Irvin
gösterdi vardır.
Ve ben bugün çok Azure üzerinde Cuma öğrendiniz.

French: 
>> Oui, nous avons rien masquer.
Et, bien sûr, il y a
cas plus intéressant à chacun d’eux,
Comment faire pour gérer les cas
où vous avez grand de documents, les clés de grande taille.
Par conséquent, il illustre les divers compromis,
les modèles que vous pouvez utiliser.
Bien sûr, il existe une tonne de documentation et
exemples en dehors de cela également dans ce référentiel.
>> Je désire que nous pourrions parler pendant une heure ou plus.
Il y a tellement grande informations et tellement
ressources utiles disponibles pour
Vous pouvez apprendre à utiliser
Azure Cosmos DB et les fonctionnalités de base de données de document qu’il contient.
Et assurez-vous que vous retirez ce référentiel de GitHub.
Tous les exemples que Irvin
a montré sont à votre disposition.
Et j’ai appris beaucoup aujourd'hui sur Azure vendredi.

Polish: 
>> tak, możemy nic nie ukryć.
Oczywiście, istnieją
bardziej interesujące sprawy, aby wszystkie te,
jak obsługiwać przypadki
Jeżeli masz duże dokumenty, dużych kluczy.
Tak więc stanowi ono ilustrację różnych skutków ubocznych,
wzorce, których można użyć.
Oczywiście istnieje mnóstwo dokumentacji i
próbki poza tym, jak również z tego repozytorium.
>> Szkoda, że możemy mówić przez co najmniej godzinę.
Istnieje tyle wielkie informacji i tyle
ogromne zasoby dostępne dla
Aby dowiedzieć się, jak używać
Azure DB kosmos i funkcje dokumentu DB w nim.
I upewnij się, że możesz sprawdzić tego repozytorium GitHub.
Wszystkie próbki tego Irvin
wykazało, są dostępne dla użytkownika.
I mam dziś dużo dzisiaj Azure piątek.

Chinese: 
>> 是的我们没有任何隐藏。
并且，当然还有
更值得关注的情况下，对所有这些，
如何处理情况
您有大型文档、 大键。
因此，它说明了不同的利弊，
您可以使用这些模式。
当然，还有大量的文档，
除了这以及此存储库中的示例。
>> 我想我们可以讨论一个小时或更多。
还有这么多好的信息和如此大
很好的可用资源
您可以了解如何使用
Azure 宇宙 DB 和它的文档数据库功能。
并确保您签出该 GitHub 存储库。
所有样本的 Irvin
介绍了可供您。
和我今天学到了很多对 Azure 上星期五。

Chinese: 
>> 是，我們隱藏執行任何動作。
而且不用說有
更有趣的情況下，所有的這些項目，
如何處理的情況下
您有大型文件、 大型金鑰。
因此，它說明了各種不同的優缺點，
您可以使用模式。
當然，沒有有大量的文件和
除了這也是此存放庫中的範例。
>> 我真希望我們無法一小時或更多談。
沒有這麼多資訊而變得
可用的絕佳資源
要了解如何使用
Azure 的宇宙 DB，並且在它的文件 DB 功能。
並確定您簽出該 GitHub 儲存機制。
所有範例的 Irvin
顯示可用於您。
然後我學到更今天在 Azure 上星期五。

Japanese: 
>> [はい] を非表示に何も実行します。
もちろんにもあります。
これらのすべてに、さらに興味深いケース
ケースを処理する方法
ドキュメントがある大規模な大規模なキーです。
など、さまざまなトレードオフを示しています
このパターンは、使用することができます。
もちろん、さまざまなドキュメントがあると
このリポジトリでもこれは別のサンプルです。
>> を望んで、1 時間以上の話できます。
非常に便利な情報よりも
使用可能なリソースを集めた
使用する方法について説明します。
Azure の世界 DB と DB のドキュメントの機能です。
GitHub のリポジトリをチェック アウトするかどうかを確認します。
すべてのサンプルを Irvin
紹介を利用します。
学んだ今日ずっと Azure の金曜日。

Spanish: 
>> Sí, ocultamos nada.
Y, por supuesto, existen
casos más interesantes a todos ellos,
cómo controlar los casos
donde haya grandes documentos grandes claves.
Por lo tanto, ilustra los diversos equilibrios,
los modelos que se pueden utilizar.
Por supuesto, hay una tonelada de documentación y
ejemplos, aparte de esto, también en este repositorio.
>> Quisiera que podríamos hablar de una hora o más.
Hay información y mucho más grandes
recursos disponibles para
aprender cómo utilizar
Azure DB Cosmos y las características de documento DB en él.
Y asegúrese de que desproteger ese repositorio de GitHub.
Todos los ejemplos de ese Irvin
demostró están disponibles para usted.
Y aprendí mucho hoy en Azure el viernes.

German: 
>> Ja, wir nichts ausblenden.
Und natürlich gibt es
interessanter Fall für alle
Behandlung von Anfragen
Dokumente, Sie haben große Tasten.
So zeigt verschiedene Nachteile,
die Muster, die Sie verwenden können.
Natürlich gibt es unzählige Dokumentation und
Beispiele daneben in diesem Repository.
>> Möchte, könnte es für eine Stunde oder mehr sprechen.
So sehr gute und Informationen so viel
großartige Ressourcen
Sie erlernen
Azure Cosmos DB und DB Funktionen der darin.
Und GitHub Repository Auschecken.
Alle Beispiele, Irvin
sind verfügbar.
Und ich heute Azure Freitag.

Czech: 
>> Ano, jsme nic skrýt.
A samozřejmě existují
na všechny tyto, zajímavější případy
způsob zpracování případů
Pokud máte velké dokumenty, velkých klíčů.
Ano ukazuje různé kompromisy
vzorky, které lze použít.
Samozřejmě existuje tuna dokumentace a
vzorků mimo to i v tomto úložišti.
>> Bych, že jsme může hovořit pro jednu hodinu či déle.
Existuje tolik skvělé informace a mnoho
velké zdroje k dispozici
k použití
Azure Cosmos DB a dokument DB funkce této aplikace.
A ujistěte se, že rezervovat dané úložiště GitHub.
Všechny vzorky této Irvin
ukázalo, jsou vám k dispozici.
A mám zkušenosti mnohem dnes na Azure pátek.

English: 
>> Yeah, we hide nothing.
And, of course, there are
more interesting cases to all of these,
how to handle cases
where you have large documents, large keys.
So, it illustrates the various tradeoffs,
the patterns that you can use.
Of course, there is a ton of documentation and
samples aside from this as well in this repository.
>> I wish we could talk for an hour or more.
There's so much great information and so much
great resources available to
you to learn how to use
Azure Cosmos DB and the document DB features in it.
And make sure you check out that GitHub repository.
All of the samples that Irvin
showed are available to you.
And I learned a lot today on Azure Friday.

Russian: 
>> Да, мы ничего не скрыть.
И, конечно же, существует
более интересными случаями ко всем из них,
как обрабатывать случаи
При наличии больших документов больших ключей.
Таким образом он иллюстрирует различные компромиссы,
шаблоны, которые можно использовать.
Конечно, есть множество документации и
Примеры Помимо этого также в этом репозитории.
>> Мне бы хотелось мы может говорить один час или более.
Есть так много отличных сведения и так много
полезные материалы для
Вы научитесь использовать
Azure Cosmos DB и возможности документа DB.
И убедитесь, что извлечение, хранилище GitHub.
Все образцы, Irvin
показал доступны для вас.
И я узнал гораздо сегодня в Azure пятница.
