Okay. Another difference is, in this class, we've been talking about SQL
and in the app store, we've got something a little different.
It's called "G-quel"--GQL
and it's basically a simplified version of SQL
that works only in the Datastore.
And the main difference is
all queries begin with SELECT*
so there's no way to select individual columns--
So this actually simplifies a lot of queries we can do.
For example, we can't do joins,
which is why I didn't want to spend a whole lot of
time on joins earlier.
Even if I were working in a SQL database,
I probably wouldn't be doing a whole lot of joins
and in the App Engine Datastore,
we won't be doing any joins whatsoever because it's not possible.
When we're using GQL--
actually, we don't even have to use GQL at all.
The Datastore has a kind of procedural language you could use as well.
But since we've spent all this time practicing SQL
and you'll probably use it elsewhere in your career,
we're going to use GQL for this example.
So we can at least have some consistency there.
Another difference is in a kind of generic
SQL database, as we've been talking about.
You can run arbitrary queries--
no matter how slow, with or without indices.
And in App Engine, all queries must be indexed.
This is important, right--because
when you're running your own database, you can do whatever you want.
But Google--it's very nice of them to give us this whole system for free--
at least for small-use cases--
but we can't beat their machines to death.
All the queries must be indexed.
It's actually not just so we don't beat them to death
but it's just the way the whole system is built.
As you get more familiar with it, it'll kind of make sense--
why things are designed the way they are.
So for the most part, in this example
that I'm going to build and your homework,
you won't actually have to build any indices yourself.
Google App Engine will actually build the indices for you,
which is really handy.
If you wanted control over what indices they build--
yes, you can do that yourself.
Sometimes, it might build, not the most efficient index,
and you can define your own--so that's pretty cool as well.
Okey. Otra diferencia es que en esta clase,
hemos estado hablando de SQL
y en la tienda de aplicaciones, tenemos
algo un poco diferente.
Se llama "G-quel" - GQL
y es básicamente una versión simplificada de SQL
que funciona sólo en el almacén de datos.
Y la diferencia principal es que
todas las consultas comienzan con SELECT*
así que no hay manera de seleccionar
columnas individuales -
Así que esto realmente simplifica muchas
consultas que podemos hacer.
Por ejemplo, no podemos hacer combinaciones,
por lo que yo no quería pasar una gran cantidad de
tiempo en las combinaciones antes.
Incluso si estuviera trabajando
en una base de datos SQL,
Yo probablemente no estaría haciendo
un montón de combinaciones
y en el almacén de datos de Aplicaciones,
nosotros no vamos a hacer combinaciones,
porque no es posible.
Cuando estamos usando GQL -
en realidad, ni siquiera tenemos
que usar GQL en absoluto.
El almacén de datos tiene una especie de lengua
de procedimiento que puedes utilizar también.
Pero ya hemos pasado todo
este tiempo practicando SQL
y es probable que lo utilices
en otro lugar en tu carrera,
vamos a utilizar GQL para este ejemplo.
Así que podemos tener al menos
un poco de coherencia allí.
Otra diferencia se encuentra en
una especie de base de datos
SQL genérica, de la que ya
hemos estado hablando.
Puedes ejecutar consultas arbitrarias -
no importa lo lento, con o sin índices.
Y en Aplicaciones, todas las preguntas
deben ser indexadas.
Esto es importante, verdad -- porque
cuando se está ejecutando tu propia base
de datos, puedes hacer lo que quieras.
Pero Google - es muy agradable por parte de ellos
darnos todo este sistema de forma gratuita -
al menos para los casos de pequeños usos -
pero no podemos vencer a sus
máquinas hasta la muerte.
Todas las consultas deben ser indexadas.
En realidad no es sólo que no les ganamos hasta la muerte
pero es sólo la forma en que todo
el sistema está construido.
A medida que te familiarices con él, tendrá sentido -
por qué las cosas están diseñadas
de la manera que lo están.
Así que para la mayor parte, en este ejemplo
que voy a construir y su tarea,
que en realidad no tendrás que construir
cualquier índice tu mismo.
Google Aplicaciones en realidad
construirá los índices por ti,
lo cual es muy práctico.
Si querías el control sobre lo
que los índices construyen -
Sí, usted puede hacerlo usted mismo.
A veces, puede construir, no el índice más eficiente,
y puedes definir el tuyo propio -
y eso es muy bueno también.
この講義ではSQLについてお話ししてきました
データストアでは少し違った話をしましょう
それはGQLと呼ばれる言語です
SQLの簡略版と言えます
データストアでしか機能しません
SQLと大きく違うのは
クエリがすべてSELECT *で始まる点です
そのため個々の列を選べず
実行可能な多くのクエリが簡素化されます
例えば結合はできません
だから講義の前半で結合について
細かく説明しなかったのです
SQLデータベースで作業していたとしても
おそらく多くの結合はやりません
GAEデータストアでは
できないので結合はやらないでしょう
GQLを使っている時と言っても
実際はGQLを使う必要はありません
データストアには一種の手続き型言語もあり
皆さんも使えます
でもSQLの演習をしてきましたし
皆さんも仕事で使うでしょうから
この例にはGQLを使いましょう
ここにはある一貫性が見られます
これまでにも説明してきた
一種の包括的なSQLデータベースにも
1つの違いがあります
任意のクエリが実行できます
遅さやインデックスの有無に関わらずです
GAEではクエリにインデックスをつけます
これは忘れないでください
自分のデータベースでは自由と言えど
Googleは少なくとも使用量が少ない場合
すべてのシステムを
無料で提供してくれます
でもGoogleの仕組みは壊せません
クエリにはインデックスが必要です
実際に私たちが仕組みを壊したりしませんが
とにかくシステム全体が構築されています
知識を身につけていく中で
設計の意図も理解できてくるはずです
ところで私がこれから挙げる例や
皆さんに出す宿題の大部分で
皆さんはインデックスを作りません
GAEがあなたに代わって作ってくれます
本当に便利です
GAEのインデックスを制御したいなら
自分で作ることもできます
最も効率的なインデックスは作れないかもしれませんが
自分で定義することができます かなりすごいことです
Outra diferença, nesta classe, é que vinhamos
falando sobre SQL
e no app store, temos algo um pouco diferente.
Que é chamado "G-quel"-- GQL
e é basicamente uma versão
simplificada do SQL
que funciona somente no Datastore.
A principal diferença é que
todas as pesquisas começam com SELECT*
assim que é impossível selecionar
colunas individuais.
Isso simplifica muito as pesquisas
que podemos fazer.
Por exemplo, não podemos fazer "joins"
que é a razão porque eu não queria gastar
muito tempo anteriormente, com os "joins".
Mesmo si estivéssemos trabalhando
num banco de dados SQL,
provavelmente eu não faria tantos "joins",
e no App Engine Datastore
não faremos nenhum, porque não se pode.
Quando usamos GQL--
na verdade, podemos não usar GQL,
si não quisermos.
O Datastore tem um tipo de linguagem processual
que também poderíamos utilizar.
Mas como passamos todo este tempo
praticando SQL
e você provavelmente o utilizará em outro
momento em sua carreira
nós vamos usar o GQL neste exemplo.
Assim podemos ao menos, ter alguma
consistência nas classes.
Outra diferença está num tipo de banco de
dados generico
do SQL, como falamos anteriormente.
Nele, você pode processar pesquisas aleatórias
não importando quão lentas,
com ou sem índices.
Já em App Engine, todas as pesquisas tem
que ser indexadas.
Isto é importante, porque quando você
estiver processando seu próprio banco de dados,
você poderá fazer como quiser.
Mas em Google-- é bem legal da parte deles nos dar
todo este sistema de graça,
ao menos para pequena utilização,
temos que seguir suas regras...
Todas as pesquisas tem que ser indexadas.
E não é só uma questão de seguir as regras
é a maneira pela qual o sistema inteiro
está construído.
Quando você se familiarizar com o sistema,
você vai entender
porque o sistema foi desenhado
desta maneira.
Então, para quase tudo, neste exemplo
que vou construir e no seu dever de casa,
você não terá que construir nenhum índice.
Google App Engine construirá por você,
o que é bastante prático.
Você pode, se quiser, controlar os índices
que eles constroem.
Algumas vezes, ele pode construir um sistema de index
que não seja muito eficiente
e aí você pode definir o seu próprio sistema, o que
também é bem legal..