blocks|key|3783783|text|BigTable是App+Engine的数据库后端，它将扩展到数百万条记录。因此，App+Engine将不允许您执行任何会导致表扫描的查询，因为对于填充良好的表，性能将非常糟糕。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3783784|换句话说，每个查询都必须使用索引。这就是为什么你只能执行=、>和<查询。(实际上，您也可以执行!=，但是该应用程序接口结合使用>和<查询来实现这一点。)这也是开发环境监视您执行的所有查询并自动将任何缺少的索引添加到index.yaml文件的原因。|offset|length|style|CODE|3783785|没有办法为LIKE查询建立索引，因此它是不可用的。|3783786|看一看this+Google+IO+session可以更好、更详细地解释这一点。|3783787|entityMap|0|LINK|mutability|MUTABLE|url|http://sites.google.com/site/io/under-the-covers-of-the-google-app-engine-datastore^0|0|S|1|U|1|W|1|1B|2|1R|1|1T|1|2Z|A|0|5|4|0|3|M|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@$D|V|E|W|F|G]|$D|X|E|Y|F|G]|$D|Z|E|10|F|G]|$D|11|E|12|F|G]|$D|13|E|14|F|G]|$D|15|E|16|F|G]|$D|17|E|18|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|19|8|@$D|1A|E|1B|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|1C|8|@]|9|@$D|1D|E|1E|1|1F]]|A|$]]|$1|L|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|M|$N|$5|O|P|Q|A|$R|S]]]]

BigTable, which is the database back end for App Engine, will scale to millions of records. Due to this, App Engine will not allow you to do any query that will result in a table scan, as performance would be dreadful for a well populated table.

In other words, every query must use an index. This is why you can only do <code>=</code>, <code>&gt;</code> and <code>&lt;</code> queries. (In fact you can also do <code>!=</code> but the API does this using a a combination of <code>&gt;</code> and <code>&lt;</code> queries.) This is also why the development environment monitors all the queries you do and automatically adds any missing indexes to your <code>index.yaml</code> file.

There is no way to index for a <code>LIKE</code> query so it's simply not available.

Have a watch of <a href="http://sites.google.com/site/io/under-the-covers-of-the-google-app-engine-datastore" rel="noreferrer">this Google IO session</a> for a much better and more detailed explanation of this.

blocks|key|5194582|text|我也面临着同样的问题，但我在谷歌应用程序引擎页面上发现了一些东西：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5194583|提示:查询筛选器没有明确的方法来匹配字符串值的一部分，但您可以使用不等式筛选器伪造前缀匹配：|5194584|db.GqlQuery("SELECT+*+FROM+MyModel+WHERE+prop+>=+:1+AND+prop+<+:2",
++++++++++++"abc",
++++++++++++u"abc"+%2B+u"\ufffd")|code-block|syntax|javascript|5194585|这将匹配每个具有以字符abc开头的字符串属性prop的MyModel实体。unicode字符串u"\ufffd“表示可能的最大Unicode字符。当属性值在索引中排序时，落在此范围内的值是以给定前缀开头的所有值。|5194586|http://code.google.com/appengine/docs/python/datastore/queriesandindexes.html|offset|length|5194587|也许这能起到这个作用。)|5194588|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|0|0|25|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Y|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Z|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|10|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|11|8|@]|9|@$M|12|N|13|1|14]]|A|$]]|$1|O|3|P|5|6|7|15|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|L]]]]

i'm facing the same problem, but i found something on google app engine pages:

Tip: Query filters do not have an explicit way to match just part of a string value, but you can fake a prefix match using inequality filters:

<pre><code>db.GqlQuery("SELECT * FROM MyModel WHERE prop &gt;= :1 AND prop &lt; :2",
 "abc",
 u"abc" + u"\ufffd")
</code></pre>

This matches every MyModel entity with a string property prop that begins with the characters abc. The unicode string u"\ufffd" represents the largest possible Unicode character. When the property values are sorted in an index, the values that fall in this range are all of the values that begin with the given prefix.

<a href="http://code.google.com/appengine/docs/python/datastore/queriesandindexes.html" rel="noreferrer">http://code.google.com/appengine/docs/python/datastore/queriesandindexes.html</a>

maybe this could do the trick ;)

blocks|key|3783902|text|尽管App+Engine不支持LIKE查询，但可以看看ListProperty和StringListProperty属性。当对这些属性进行相等性测试时，该测试实际上将应用于所有列表成员，例如，如果值出现在列表中的任何位置，则list_property+=+value测试。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3783903|有时，此功能可能被用作缺少LIKE查询的变通方法。例如，它使得做simple+text+search,+as+described+on+this+post成为可能。|3783904|entityMap|0|LINK|mutability|MUTABLE|url|http://code.google.com/appengine/docs/python/datastore/typesandpropertyclasses.html#ListProperty|1|http://code.google.com/appengine/docs/python/datastore/typesandpropertyclasses.html#StringListProperty|2|http://www.billkatz.com/2009/6/Simple-Full-Text-Search-for-App-Engine^0|34|L|R|C|0|14|I|1|0|W|19|2|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@$9|W|A|X|1|Y]|$9|Z|A|10|1|11]]|E|$]]|$1|F|3|G|5|6|7|12|8|@]|D|@$9|13|A|14|1|15]]|E|$]]|$1|H|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]|P|$5|K|L|M|E|$N|Q]]|R|$5|K|L|M|E|$N|S]]]]

Altough App Engine does not support LIKE queries, have a look at the properties <a href="http://code.google.com/appengine/docs/python/datastore/typesandpropertyclasses.html#ListProperty" rel="noreferrer">ListProperty</a> and <a href="http://code.google.com/appengine/docs/python/datastore/typesandpropertyclasses.html#StringListProperty" rel="noreferrer">StringListProperty</a>. When an equality test is done on these properties, the test will actually be applied on all list members, e.g., <code>list_property = value</code> tests if the value appears anywhere in the list.

Sometimes this feature might be used as a workaround to the lack of LIKE queries. For instance, it makes it possible to do <a href="http://www.billkatz.com/2009/6/Simple-Full-Text-Search-for-App-Engine" rel="noreferrer">simple text search, as described on this post</a>.

blocks|key|3783946|text|看一下Objectify+API，它就像一个数据存储访问here。这里有一个关于这个问题的常见问题解答，下面是答案|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3783947|3783948|如何执行like查询(如"foo%25")|blockquote|3783949|3783950|如果在存储和搜索时颠倒了顺序，则可以执行startWith或endWith之类的操作。您使用所需的起始值和恰好高于所需值的值执行范围查询。|3783951|3783952|String+start+=+"foo";
++++...+=+ofy.query(MyEntity.class).filter("field+>=",+start).filter("field+<",+start+%2B+"\uFFFD");|code-block|syntax|javascript|3783953|entityMap|0|LINK|mutability|MUTABLE|url|http://code.google.com/p/objectify-appengine/wiki/FrequentlyAskedQuestions#How_do_I_do_a_like_query_%2528LIKE_%2522foo%25%2522%2529^0|S|4|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|-4|5|6|7|12|8|@]|9|@]|C|$]]|$1|E|3|F|5|G|7|13|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|14|8|@]|9|@]|C|$]]|$1|I|3|J|5|6|7|15|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|16|8|@]|9|@]|C|$]]|$1|L|3|M|5|N|7|17|8|@]|9|@]|C|$O|P]]|$1|Q|3|-4|5|6|7|18|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

Have a look at Objectify <a href="http://code.google.com/p/objectify-appengine/wiki/FrequentlyAskedQuestions#How_do_I_do_a_like_query_%28LIKE_%22foo%%22%29" rel="nofollow">here</a> , it is like a Datastore access API. There is a FAQ with this question specifically, here is the answer

<blockquote>
 How do I do a like query (LIKE "foo%") 
 You can do something like a startWith, or endWith if you reverse the order when stored and searched. You do a range query with the starting value you want, and a value just above the one you want.
</blockquote>

<pre><code>String start = "foo";
 ... = ofy.query(MyEntity.class).filter("field &gt;=", start).filter("field &lt;", start + "\uFFFD");
</code></pre>

blocks|key|3784285|text|如果LIKE+'%25text%25'总是与一个或几个单词进行比较(考虑排列)，并且数据更改缓慢(缓慢意味着创建和更新索引的成本并不高-无论是价格上还是性能上)，那么Relation+(RIE)可能就是答案。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3784286|是的，您必须构建额外的数据存储实体并适当地填充它。是的，您必须绕过一些限制(其中一个限制是GAE数据存储中list属性的长度限制为5000+)。但是搜索结果是闪电般的快。|3784287|有关详细信息，请参阅我的RIE+with+Java+and+Ojbectify和RIE+with+Python帖子。|3784288|entityMap|0|LINK|mutability|MUTABLE|url|http://novyden.blogspot.com/2011/02/efficient-keyword-search-with-relation.html|1|http://novyden.blogspot.com/2011/09/efficient-keyword-search-with-relation.html^0|2|D|0|0|C|R|0|14|F|1|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|W|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|X|8|@]|D|@$9|Y|A|Z|1|10]|$9|11|A|12|1|13]]|E|$]]|$1|J|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|K|$L|$5|M|N|O|E|$P|Q]]|R|$5|M|N|O|E|$P|S]]]]

If the <code>LIKE '%text%'</code> always compares to a word or a few (think permutations) and your data changes slowly (slowly means that it's not prohibitively expensive - both price-wise and performance-wise - to create and updates indexes) then Relation Index Entity (RIE) may be the answer. 

Yes, you will have to build additional datastore entity and populate it appropriately. Yes, there are some constraints that you will have to play around (one is 5000 limit on the length of list property in GAE datastore). But the resulting searches are lightning fast. 

For details see my <a href="http://novyden.blogspot.com/2011/02/efficient-keyword-search-with-relation.html" rel="nofollow">RIE with Java and Ojbectify</a> and <a href="http://novyden.blogspot.com/2011/09/efficient-keyword-search-with-relation.html" rel="nofollow">RIE with Python</a> posts.

blocks|key|2939394|text|"Like“经常被用来代替文本搜索。对于文本搜索，可以使用Whoosh-AppEngine。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2939395|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/tallstreet/Whoosh-AppEngine^0|T|G|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

"Like" is often uses as a poor-man's substitute for text search. For text search, it is possible to use <a href="https://github.com/tallstreet/Whoosh-AppEngine" rel="nofollow">Whoosh-AppEngine</a>.

blocks|key|5194940|text|只需关注此处:+init.py#354">http://code.google.com/p/googleappengine/source/browse/trunk/python/google/appengine/ext/search/.py#354|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|5194941|它起作用了!|5194942|class+Article(search.SearchableModel):
++++text+=+db.TextProperty()
++++...

++article+=+Article(text=...)
++article.save()

To+search+the+full+text+index,+use+the+SearchableModel.all()+method+to+get+an
instance+of+SearchableModel.Query,+which+subclasses+db.Query.+Use+its+search()
method+to+provide+a+search+query,+in+addition+to+any+other+filters+or+sort
orders,+e.g.:

++query+=+article.all().search('a+search+query').filter(...).order(...)|code-block|syntax|javascript|5194943|entityMap|0|LINK|mutability|MUTABLE|url|http://code.google.com/p/googleappengine/source/browse/trunk/python/google/appengine/ext/search/**init**.py#354^0|L|2V|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

Just follow here:
init.py#354">http://code.google.com/p/googleappengine/source/browse/trunk/python/google/appengine/ext/search/init.py#354

It works!

<pre><code>class Article(search.SearchableModel):
 text = db.TextProperty()
 ...

 article = Article(text=...)
 article.save()

To search the full text index, use the SearchableModel.all() method to get an
instance of SearchableModel.Query, which subclasses db.Query. Use its search()
method to provide a search query, in addition to any other filters or sort
orders, e.g.:

 query = article.all().search('a search query').filter(...).order(...)
</code></pre>

blocks|key|727112|text|App+engine在1.7.0版本中发布了一个支持数据存储的通用full+text+search+service。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|727113|详细信息在announcement中。|727114|有关如何使用它的更多信息：https://cloud.google.com/appengine/training/fts_intro/lesson2|727115|entityMap|0|LINK|mutability|MUTABLE|url|https://developers.google.com/appengine/docs/python/search/overview|1|http://googleappengine.blogspot.com/2012/05/looking-for-search-find-it-on-google.html|2|https://cloud.google.com/appengine/training/fts_intro/lesson2^0|X|O|0|0|5|C|1|0|D|1P|2|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]]|C|$]]|$1|D|3|E|5|6|7|X|8|@]|9|@$A|Y|B|Z|1|10]]|C|$]]|$1|F|3|G|5|6|7|11|8|@]|9|@$A|12|B|13|1|14]]|C|$]]|$1|H|3|-4|5|6|7|15|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]|P|$5|K|L|M|C|$N|Q]]|R|$5|K|L|M|C|$N|S]]]]

App engine launched a general-purpose <a href="https://developers.google.com/appengine/docs/python/search/overview" rel="nofollow">full text search service</a> in version 1.7.0 that supports the datastore. 

Details in the <a href="http://googleappengine.blogspot.com/2012/05/looking-for-search-find-it-on-google.html" rel="nofollow">announcement</a>.

More information on how to use this: <a href="https://cloud.google.com/appengine/training/fts_intro/lesson2" rel="nofollow">https://cloud.google.com/appengine/training/fts_intro/lesson2</a>

blocks|key|5195074|text|需要使用search+service执行与SQL+LIKE类似的全文搜索查询。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5195075|Gaelyk提供特定于领域的语言来执行更多的user+friendly+search+queries。例如，下面的代码片段将从标题包含fern且流派与thriller完全匹配的最新图书中查找前十本图书|5195076|def+documents+=+search.search+{
++++select+all+from+books
++++sort+desc+by+published,+SearchApiLimits.MINIMUM_DATE_VALUE
++++where+title+=~+'fern'
++++and+genre+=++'thriller'
++++limit+10
}|code-block|syntax|javascript|5195077|Like被编写为Groovy的匹配操作符=~。它还支持distance(geopoint(lat,+lon),+location)等功能。|5195078|entityMap|0|LINK|mutability|MUTABLE|url|https://developers.google.com/appengine/docs/java/search/|1|http://gaelyk.appspot.com/|2|http://gaelyk.appspot.com/tutorial/app-engine-shortcuts#advanced_fulltext_search^0|P|4|4|E|0|0|1V|4|23|8|0|6|1|M|S|2|0|0|K|2|R|12|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@$9|13|A|14|1|15]]|E|$]]|$1|F|3|G|5|6|7|16|8|@$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@$9|1B|A|1C|1|1D]|$9|1E|A|1F|1|1G]]|E|$]]|$1|H|3|I|5|J|7|1H|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1I|8|@$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|1N|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]|W|$5|R|S|T|E|$U|X]]|Y|$5|R|S|T|E|$U|Z]]]]

You need to use <a href="https://developers.google.com/appengine/docs/java/search/">search service</a> to perform full text search queries similar to SQL <code>LIKE</code>.

<a href="http://gaelyk.appspot.com/">Gaelyk</a> provides domain specific language to perform more <a href="http://gaelyk.appspot.com/tutorial/app-engine-shortcuts#advanced_fulltext_search">user friendly search queries</a>. For example following snippet will find first ten books sorted from the latest ones with title containing <code>fern</code>
and the genre exactly matching <code>thriller</code>:

<pre><code>def documents = search.search {
 select all from books
 sort desc by published, SearchApiLimits.MINIMUM_DATE_VALUE
 where title =~ 'fern'
 and genre = 'thriller'
 limit 10
}
</code></pre>

Like is written as Groovy's match operator <code>=~</code>.
It supports functions such as <code>distance(geopoint(lat, lon), location)</code> as well.

blocks|key|5195122|text|我使用GAE+Datastore低级Java+API对此进行了测试。我，并且工作得很完美|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5195123|++++Query+q+=+new+Query(Directorio.class.getSimpleName());

++++Filter+filterNombreGreater+=+new+FilterPredicate("nombre",+FilterOperator.GREATER_THAN_OR_EQUAL,+query);
++++Filter+filterNombreLess+=+new+FilterPredicate("nombre",+FilterOperator.LESS_THAN,+query%2B"\uFFFD");
++++Filter+filterNombre+=++CompositeFilterOperator.and(filterNombreGreater,+filterNombreLess);

++++q.setFilter(filter);|code-block|syntax|javascript|5195124|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I tested this with GAE Datastore low-level Java API. Me and works perfectly

<pre><code> Query q = new Query(Directorio.class.getSimpleName());

 Filter filterNombreGreater = new FilterPredicate("nombre", FilterOperator.GREATER_THAN_OR_EQUAL, query);
 Filter filterNombreLess = new FilterPredicate("nombre", FilterOperator.LESS_THAN, query+"\uFFFD");
 Filter filterNombre = CompositeFilterOperator.and(filterNombreGreater, filterNombreLess);

 q.setFilter(filter);
</code></pre>

blocks|key|5195199|text|一般来说，即使这是一个老帖子，生成“LIKE”或“ILIKE”的一种方法是收集“>=”查询的所有结果，然后在python+(或Java)中循环结果以查找包含您要查找的元素。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5195200|假设您想要过滤给定q='luigi‘的用户|5195201|users+=+[]
qry+=+self.user_model.query(ndb.OR(self.user_model.name+>=+q.lower(),self.user_model.email+>=+q.lower(),self.user_model.username+>=+q.lower()))

for+_qry+in+qry:
+if+q.lower()+in+_qry.name.lower()+or+q.lower()+in+_qry.email.lower()+or+q.lower()+in+_qry.username.lower():
++++++users.append(_qry)|code-block|syntax|javascript|5195202|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

In general, even though this is an old post, a way to produce a 'LIKE' or 'ILIKE' is to gather all results from a '>=' query, then loop results in python (or Java) for elements containing what you're looking for.

Let's say you want to filter users given a q='luigi'

<pre><code>users = []
qry = self.user_model.query(ndb.OR(self.user_model.name &gt;= q.lower(),self.user_model.email &gt;= q.lower(),self.user_model.username &gt;= q.lower()))

for _qry in qry:
 if q.lower() in _qry.name.lower() or q.lower() in _qry.email.lower() or q.lower() in _qry.username.lower():
 users.append(_qry)
</code></pre>

blocks|key|2939889|text|在数据存储应用程序引擎上不可能进行LIKE搜索，如果您需要在字符串中搜索一个单词，那么创建一个数组列表就可以做到这一点。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2939890|@Index
++++public+ArrayList<String>+searchName;|code-block|syntax|javascript|2939891|然后使用objectify在索引中进行搜索。|2939892|List<Profiles>+list1+=+ofy().load().type(Profiles.class).filter("searchName+=",search).list();|2939893|这将为您提供一个列表，其中包含您在搜索中所做的所有项目|2939894|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

It is not possible to do a LIKE search on datastore app engine, how ever creating an Arraylist would do the trick if you need to search a word in a string. 

<pre><code>@Index
 public ArrayList&lt;String&gt; searchName;
</code></pre>

and then to search in the index using objectify.

<pre><code>List&lt;Profiles&gt; list1 = ofy().load().type(Profiles.class).filter("searchName =",search).list();
</code></pre>

and this will give you a list with all the items that contain the world you did on the search

Simple one really. In SQL, if I want to search a text field for a couple of characters, I can do:

<pre><code>SELECT blah FROM blah WHERE blah LIKE '%text%'
</code></pre>

The documentation for App Engine makes no mention of how to achieve this, but surely it's a common enough problem?

Google App Engine: Is it possible to do a Gql LIKE query?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

真的很简单。在SQL中，如果我想在文本字段中搜索几个字符，我可以这样做：SELECT blah FROM blah WHERE blah LIKE '%text%'App Engine的文档没有提到如何实现这一点，但这肯定是一个足够常见的问题？

问Google App Engine:可以执行类似Gql的查询吗？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Google App Engine:可以执行类似Gql的查询吗？EN