1 #!/usr/bin/env python

     2 #

     3 # Copyright 2007 Google Inc.

     4 #

     5 # Licensed under the Apache License, Version 2.0 (the "License");

     6 # you may not use this file except in compliance with the License.

     7 # You may obtain a copy of the License at

     8 #

     9 #     http://www.apache.org/licenses/LICENSE-2.0

    10 #

    11 # Unless required by applicable law or agreed to in writing, software

    12 # distributed under the License is distributed on an "AS IS" BASIS,

    13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

    14 # See the License for the specific language governing permissions and

    15 # limitations under the License.

    16 #

    17 

    18 from google.net.proto import ProtocolBuffer

    19 import array

    20 import dummy_thread as thread

    21 

    22 __pychecker__ = """maxreturns=0 maxbranches=0 no-callinit

    23                    unusednames=printElemNumber,debug_strs no-special"""

    24 

    25 from google.appengine.api.api_base_pb import Integer64Proto;

    26 from google.appengine.api.api_base_pb import StringProto;

    27 from google.appengine.api.api_base_pb import VoidProto;

    28 from google.appengine.datastore.entity_pb import CompositeIndex

    29 from google.appengine.datastore.entity_pb import EntityProto

    30 from google.appengine.datastore.entity_pb import Index

    31 from google.appengine.datastore.entity_pb import Property

    32 from google.appengine.datastore.entity_pb import Reference

    33 class Transaction(ProtocolBuffer.ProtocolMessage):

    34   def __init__(self, contents=None):

    35     self.handle_ = 0

    36     self.has_handle_ = 0

    37     if contents is not None: self.MergeFromString(contents)

    38 

    39   def handle(self): return self.handle_

    40 

    41   def set_handle(self, x):

    42     self.has_handle_ = 1

    43     self.handle_ = x

    44 

    45   def clear_handle(self):

    46     self.has_handle_ = 0

    47     self.handle_ = 0

    48 

    49   def has_handle(self): return self.has_handle_

    50 

    51 

    52   def MergeFrom(self, x):

    53     assert x is not self

    54     if (x.has_handle()): self.set_handle(x.handle())

    55 

    56   def Equals(self, x):

    57     if x is self: return 1

    58     if self.has_handle_ != x.has_handle_: return 0

    59     if self.has_handle_ and self.handle_ != x.handle_: return 0

    60     return 1

    61 

    62   def __eq__(self, other):

    63     return (other is not None) and (other.__class__ == self.__class__) and self.Equals(other)

    64 

    65   def __ne__(self, other):

    66     return not (self == other)

    67 

    68   def IsInitialized(self, debug_strs=None):

    69     initialized = 1

    70     if (not self.has_handle_):

    71       initialized = 0

    72       if debug_strs is not None:

    73         debug_strs.append('Required field: handle not set.')

    74     return initialized

    75 

    76   def ByteSize(self):

    77     n = 0

    78     return n + 9

    79 

    80   def Clear(self):

    81     self.clear_handle()

    82 

    83   def OutputUnchecked(self, out):

    84     out.putVarInt32(9)

    85     out.put64(self.handle_)

    86 

    87   def TryMerge(self, d):

    88     while d.avail() > 0:

    89       tt = d.getVarInt32()

    90       if tt == 9:

    91         self.set_handle(d.get64())

    92         continue

    93       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError

    94       d.skipData(tt)

    95 

    96 

    97   def __str__(self, prefix="", printElemNumber=0):

    98     res=""

    99     if self.has_handle_: res+=prefix+("handle: %s\n" % self.DebugFormatFixed64(self.handle_))

   100     return res

   101 

   102   khandle = 1

   103 

   104   _TEXT = (

   105    "ErrorCode",

   106    "handle",

   107   )

   108 

   109   _TYPES = (

   110    ProtocolBuffer.Encoder.NUMERIC,

   111    ProtocolBuffer.Encoder.DOUBLE,

   112 

   113   )

   114 

   115   _STYLE = """"""

   116   _STYLE_CONTENT_TYPE = """"""

   117 class Query_Filter(ProtocolBuffer.ProtocolMessage):

   118 

   119   LESS_THAN    =    1

   120   LESS_THAN_OR_EQUAL =    2

   121   GREATER_THAN =    3

   122   GREATER_THAN_OR_EQUAL =    4

   123   EQUAL        =    5

   124   IN           =    6

   125   EXISTS       =    7

   126 

   127   _Operator_NAMES = {

   128     1: "LESS_THAN",

   129     2: "LESS_THAN_OR_EQUAL",

   130     3: "GREATER_THAN",

   131     4: "GREATER_THAN_OR_EQUAL",

   132     5: "EQUAL",

   133     6: "IN",

   134     7: "EXISTS",

   135   }

   136 

   137   def Operator_Name(cls, x): return cls._Operator_NAMES.get(x, "")

   138   Operator_Name = classmethod(Operator_Name)

   139 

   140   def __init__(self, contents=None):

   141     self.op_ = 0

   142     self.property_ = []

   143     self.has_op_ = 0

   144     if contents is not None: self.MergeFromString(contents)

   145 

   146   def op(self): return self.op_

   147 

   148   def set_op(self, x):

   149     self.has_op_ = 1

   150     self.op_ = x

   151 

   152   def clear_op(self):

   153     self.has_op_ = 0

   154     self.op_ = 0

   155 

   156   def has_op(self): return self.has_op_

   157 

   158   def property_size(self): return len(self.property_)

   159   def property_list(self): return self.property_

   160 

   161   def property(self, i):

   162     return self.property_[i]

   163 

   164   def mutable_property(self, i):

   165     return self.property_[i]

   166 

   167   def add_property(self):

   168     x = Property()

   169     self.property_.append(x)

   170     return x

   171 

   172   def clear_property(self):

   173     self.property_ = []

   174 

   175   def MergeFrom(self, x):

   176     assert x is not self

   177     if (x.has_op()): self.set_op(x.op())

   178     for i in xrange(x.property_size()): self.add_property().CopyFrom(x.property(i))

   179 

   180   def Equals(self, x):

   181     if x is self: return 1

   182     if self.has_op_ != x.has_op_: return 0

   183     if self.has_op_ and self.op_ != x.op_: return 0

   184     if len(self.property_) != len(x.property_): return 0

   185     for e1, e2 in zip(self.property_, x.property_):

   186       if e1 != e2: return 0

   187     return 1

   188 

   189   def __eq__(self, other):

   190     return (other is not None) and (other.__class__ == self.__class__) and self.Equals(other)

   191 

   192   def __ne__(self, other):

   193     return not (self == other)

   194 

   195   def IsInitialized(self, debug_strs=None):

   196     initialized = 1

   197     if (not self.has_op_):

   198       initialized = 0

   199       if debug_strs is not None:

   200         debug_strs.append('Required field: op not set.')

   201     for i in xrange(len(self.property_)):

   202       if (not self.property_[i].IsInitialized(debug_strs)): initialized=0

   203     return initialized

   204 

   205   def ByteSize(self):

   206     n = 0

   207     n += self.lengthVarInt64(self.op_)

   208     n += 1 * len(self.property_)

   209     for i in xrange(len(self.property_)): n += self.lengthString(self.property_[i].ByteSize())

   210     return n + 1

   211 

   212   def Clear(self):

   213     self.clear_op()

   214     self.clear_property()

   215 

   216   def OutputUnchecked(self, out):

   217     out.putVarInt32(48)

   218     out.putVarInt32(self.op_)

   219     for i in xrange(len(self.property_)):

   220       out.putVarInt32(114)

   221       out.putVarInt32(self.property_[i].ByteSize())

   222       self.property_[i].OutputUnchecked(out)

   223 

   224   def TryMerge(self, d):

   225     while 1:

   226       tt = d.getVarInt32()

   227       if tt == 36: break

   228       if tt == 48:

   229         self.set_op(d.getVarInt32())

   230         continue

   231       if tt == 114:

   232         length = d.getVarInt32()

   233         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)

   234         d.skip(length)

   235         self.add_property().TryMerge(tmp)

   236         continue

   237       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError

   238       d.skipData(tt)

   239 

   240 

   241   def __str__(self, prefix="", printElemNumber=0):

   242     res=""

   243     if self.has_op_: res+=prefix+("op: %s\n" % self.DebugFormatInt32(self.op_))

   244     cnt=0

   245     for e in self.property_:

   246       elm=""

   247       if printElemNumber: elm="(%d)" % cnt

   248       res+=prefix+("property%s <\n" % elm)

   249       res+=e.__str__(prefix + "  ", printElemNumber)

   250       res+=prefix+">\n"

   251       cnt+=1

   252     return res

   253 

   254 class Query_Order(ProtocolBuffer.ProtocolMessage):

   255 

   256   ASCENDING    =    1

   257   DESCENDING   =    2

   258 

   259   _Direction_NAMES = {

   260     1: "ASCENDING",

   261     2: "DESCENDING",

   262   }

   263 

   264   def Direction_Name(cls, x): return cls._Direction_NAMES.get(x, "")

   265   Direction_Name = classmethod(Direction_Name)

   266 

   267   def __init__(self, contents=None):

   268     self.property_ = ""

   269     self.direction_ = 1

   270     self.has_property_ = 0

   271     self.has_direction_ = 0

   272     if contents is not None: self.MergeFromString(contents)

   273 

   274   def property(self): return self.property_

   275 

   276   def set_property(self, x):

   277     self.has_property_ = 1

   278     self.property_ = x

   279 

   280   def clear_property(self):

   281     self.has_property_ = 0

   282     self.property_ = ""

   283 

   284   def has_property(self): return self.has_property_

   285 

   286   def direction(self): return self.direction_

   287 

   288   def set_direction(self, x):

   289     self.has_direction_ = 1

   290     self.direction_ = x

   291 

   292   def clear_direction(self):

   293     self.has_direction_ = 0

   294     self.direction_ = 1

   295 

   296   def has_direction(self): return self.has_direction_

   297 

   298 

   299   def MergeFrom(self, x):

   300     assert x is not self

   301     if (x.has_property()): self.set_property(x.property())

   302     if (x.has_direction()): self.set_direction(x.direction())

   303 

   304   def Equals(self, x):

   305     if x is self: return 1

   306     if self.has_property_ != x.has_property_: return 0

   307     if self.has_property_ and self.property_ != x.property_: return 0

   308     if self.has_direction_ != x.has_direction_: return 0

   309     if self.has_direction_ and self.direction_ != x.direction_: return 0

   310     return 1

   311 

   312   def __eq__(self, other):

   313     return (other is not None) and (other.__class__ == self.__class__) and self.Equals(other)

   314 

   315   def __ne__(self, other):

   316     return not (self == other)

   317 

   318   def IsInitialized(self, debug_strs=None):

   319     initialized = 1

   320     if (not self.has_property_):

   321       initialized = 0

   322       if debug_strs is not None:

   323         debug_strs.append('Required field: property not set.')

   324     return initialized

   325 

   326   def ByteSize(self):

   327     n = 0

   328     n += self.lengthString(len(self.property_))

   329     if (self.has_direction_): n += 1 + self.lengthVarInt64(self.direction_)

   330     return n + 1

   331 

   332   def Clear(self):

   333     self.clear_property()

   334     self.clear_direction()

   335 

   336   def OutputUnchecked(self, out):

   337     out.putVarInt32(82)

   338     out.putPrefixedString(self.property_)

   339     if (self.has_direction_):

   340       out.putVarInt32(88)

   341       out.putVarInt32(self.direction_)

   342 

   343   def TryMerge(self, d):

   344     while 1:

   345       tt = d.getVarInt32()

   346       if tt == 76: break

   347       if tt == 82:

   348         self.set_property(d.getPrefixedString())

   349         continue

   350       if tt == 88:

   351         self.set_direction(d.getVarInt32())

   352         continue

   353       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError

   354       d.skipData(tt)

   355 

   356 

   357   def __str__(self, prefix="", printElemNumber=0):

   358     res=""

   359     if self.has_property_: res+=prefix+("property: %s\n" % self.DebugFormatString(self.property_))

   360     if self.has_direction_: res+=prefix+("direction: %s\n" % self.DebugFormatInt32(self.direction_))

   361     return res

   362 

   363 class Query(ProtocolBuffer.ProtocolMessage):

   364 

   365   ORDER_FIRST  =    1

   366   ANCESTOR_FIRST =    2

   367   FILTER_FIRST =    3

   368 

   369   _Plan_NAMES = {

   370     1: "ORDER_FIRST",

   371     2: "ANCESTOR_FIRST",

   372     3: "FILTER_FIRST",

   373   }

   374 

   375   def Plan_Name(cls, x): return cls._Plan_NAMES.get(x, "")

   376   Plan_Name = classmethod(Plan_Name)

   377 

   378   def __init__(self, contents=None):

   379     self.app_ = ""

   380     self.kind_ = ""

   381     self.ancestor_ = None

   382     self.filter_ = []

   383     self.search_query_ = ""

   384     self.order_ = []

   385     self.hint_ = 0

   386     self.offset_ = 0

   387     self.limit_ = 0

   388     self.composite_index_ = []

   389     self.require_perfect_plan_ = 0

   390     self.has_app_ = 0

   391     self.has_kind_ = 0

   392     self.has_ancestor_ = 0

   393     self.has_search_query_ = 0

   394     self.has_hint_ = 0

   395     self.has_offset_ = 0

   396     self.has_limit_ = 0

   397     self.has_require_perfect_plan_ = 0

   398     self.lazy_init_lock_ = thread.allocate_lock()

   399     if contents is not None: self.MergeFromString(contents)

   400 

   401   def app(self): return self.app_

   402 

   403   def set_app(self, x):

   404     self.has_app_ = 1

   405     self.app_ = x

   406 

   407   def clear_app(self):

   408     self.has_app_ = 0

   409     self.app_ = ""

   410 

   411   def has_app(self): return self.has_app_

   412 

   413   def kind(self): return self.kind_

   414 

   415   def set_kind(self, x):

   416     self.has_kind_ = 1

   417     self.kind_ = x

   418 

   419   def clear_kind(self):

   420     self.has_kind_ = 0

   421     self.kind_ = ""

   422 

   423   def has_kind(self): return self.has_kind_

   424 

   425   def ancestor(self):

   426     if self.ancestor_ is None:

   427       self.lazy_init_lock_.acquire()

   428       try:

   429         if self.ancestor_ is None: self.ancestor_ = Reference()

   430       finally:

   431         self.lazy_init_lock_.release()

   432     return self.ancestor_

   433 

   434   def mutable_ancestor(self): self.has_ancestor_ = 1; return self.ancestor()

   435 

   436   def clear_ancestor(self):

   437     self.has_ancestor_ = 0;

   438     if self.ancestor_ is not None: self.ancestor_.Clear()

   439 

   440   def has_ancestor(self): return self.has_ancestor_

   441 

   442   def filter_size(self): return len(self.filter_)

   443   def filter_list(self): return self.filter_

   444 

   445   def filter(self, i):

   446     return self.filter_[i]

   447 

   448   def mutable_filter(self, i):

   449     return self.filter_[i]

   450 

   451   def add_filter(self):

   452     x = Query_Filter()

   453     self.filter_.append(x)

   454     return x

   455 

   456   def clear_filter(self):

   457     self.filter_ = []

   458   def search_query(self): return self.search_query_

   459 

   460   def set_search_query(self, x):

   461     self.has_search_query_ = 1

   462     self.search_query_ = x

   463 

   464   def clear_search_query(self):

   465     self.has_search_query_ = 0

   466     self.search_query_ = ""

   467 

   468   def has_search_query(self): return self.has_search_query_

   469 

   470   def order_size(self): return len(self.order_)

   471   def order_list(self): return self.order_

   472 

   473   def order(self, i):

   474     return self.order_[i]

   475 

   476   def mutable_order(self, i):

   477     return self.order_[i]

   478 

   479   def add_order(self):

   480     x = Query_Order()

   481     self.order_.append(x)

   482     return x

   483 

   484   def clear_order(self):

   485     self.order_ = []

   486   def hint(self): return self.hint_

   487 

   488   def set_hint(self, x):

   489     self.has_hint_ = 1

   490     self.hint_ = x

   491 

   492   def clear_hint(self):

   493     self.has_hint_ = 0

   494     self.hint_ = 0

   495 

   496   def has_hint(self): return self.has_hint_

   497 

   498   def offset(self): return self.offset_

   499 

   500   def set_offset(self, x):

   501     self.has_offset_ = 1

   502     self.offset_ = x

   503 

   504   def clear_offset(self):

   505     self.has_offset_ = 0

   506     self.offset_ = 0

   507 

   508   def has_offset(self): return self.has_offset_

   509 

   510   def limit(self): return self.limit_

   511 

   512   def set_limit(self, x):

   513     self.has_limit_ = 1

   514     self.limit_ = x

   515 

   516   def clear_limit(self):

   517     self.has_limit_ = 0

   518     self.limit_ = 0

   519 

   520   def has_limit(self): return self.has_limit_

   521 

   522   def composite_index_size(self): return len(self.composite_index_)

   523   def composite_index_list(self): return self.composite_index_

   524 

   525   def composite_index(self, i):

   526     return self.composite_index_[i]

   527 

   528   def mutable_composite_index(self, i):

   529     return self.composite_index_[i]

   530 

   531   def add_composite_index(self):

   532     x = CompositeIndex()

   533     self.composite_index_.append(x)

   534     return x

   535 

   536   def clear_composite_index(self):

   537     self.composite_index_ = []

   538   def require_perfect_plan(self): return self.require_perfect_plan_

   539 

   540   def set_require_perfect_plan(self, x):

   541     self.has_require_perfect_plan_ = 1

   542     self.require_perfect_plan_ = x

   543 

   544   def clear_require_perfect_plan(self):

   545     self.has_require_perfect_plan_ = 0

   546     self.require_perfect_plan_ = 0

   547 

   548   def has_require_perfect_plan(self): return self.has_require_perfect_plan_

   549 

   550 

   551   def MergeFrom(self, x):

   552     assert x is not self

   553     if (x.has_app()): self.set_app(x.app())

   554     if (x.has_kind()): self.set_kind(x.kind())

   555     if (x.has_ancestor()): self.mutable_ancestor().MergeFrom(x.ancestor())

   556     for i in xrange(x.filter_size()): self.add_filter().CopyFrom(x.filter(i))

   557     if (x.has_search_query()): self.set_search_query(x.search_query())

   558     for i in xrange(x.order_size()): self.add_order().CopyFrom(x.order(i))

   559     if (x.has_hint()): self.set_hint(x.hint())

   560     if (x.has_offset()): self.set_offset(x.offset())

   561     if (x.has_limit()): self.set_limit(x.limit())

   562     for i in xrange(x.composite_index_size()): self.add_composite_index().CopyFrom(x.composite_index(i))

   563     if (x.has_require_perfect_plan()): self.set_require_perfect_plan(x.require_perfect_plan())

   564 

   565   def Equals(self, x):

   566     if x is self: return 1

   567     if self.has_app_ != x.has_app_: return 0

   568     if self.has_app_ and self.app_ != x.app_: return 0

   569     if self.has_kind_ != x.has_kind_: return 0

   570     if self.has_kind_ and self.kind_ != x.kind_: return 0

   571     if self.has_ancestor_ != x.has_ancestor_: return 0

   572     if self.has_ancestor_ and self.ancestor_ != x.ancestor_: return 0

   573     if len(self.filter_) != len(x.filter_): return 0

   574     for e1, e2 in zip(self.filter_, x.filter_):

   575       if e1 != e2: return 0

   576     if self.has_search_query_ != x.has_search_query_: return 0

   577     if self.has_search_query_ and self.search_query_ != x.search_query_: return 0

   578     if len(self.order_) != len(x.order_): return 0

   579     for e1, e2 in zip(self.order_, x.order_):

   580       if e1 != e2: return 0

   581     if self.has_hint_ != x.has_hint_: return 0

   582     if self.has_hint_ and self.hint_ != x.hint_: return 0

   583     if self.has_offset_ != x.has_offset_: return 0

   584     if self.has_offset_ and self.offset_ != x.offset_: return 0

   585     if self.has_limit_ != x.has_limit_: return 0

   586     if self.has_limit_ and self.limit_ != x.limit_: return 0

   587     if len(self.composite_index_) != len(x.composite_index_): return 0

   588     for e1, e2 in zip(self.composite_index_, x.composite_index_):

   589       if e1 != e2: return 0

   590     if self.has_require_perfect_plan_ != x.has_require_perfect_plan_: return 0

   591     if self.has_require_perfect_plan_ and self.require_perfect_plan_ != x.require_perfect_plan_: return 0

   592     return 1

   593 

   594   def __eq__(self, other):

   595     return (other is not None) and (other.__class__ == self.__class__) and self.Equals(other)

   596 

   597   def __ne__(self, other):

   598     return not (self == other)

   599 

   600   def IsInitialized(self, debug_strs=None):

   601     initialized = 1

   602     if (not self.has_app_):

   603       initialized = 0

   604       if debug_strs is not None:

   605         debug_strs.append('Required field: app not set.')

   606     if (self.has_ancestor_ and not self.ancestor_.IsInitialized(debug_strs)): initialized = 0

   607     for i in xrange(len(self.filter_)):

   608       if (not self.filter_[i].IsInitialized(debug_strs)): initialized=0

   609     for i in xrange(len(self.order_)):

   610       if (not self.order_[i].IsInitialized(debug_strs)): initialized=0

   611     for i in xrange(len(self.composite_index_)):

   612       if (not self.composite_index_[i].IsInitialized(debug_strs)): initialized=0

   613     return initialized

   614 

   615   def ByteSize(self):

   616     n = 0

   617     n += self.lengthString(len(self.app_))

   618     if (self.has_kind_): n += 1 + self.lengthString(len(self.kind_))

   619     if (self.has_ancestor_): n += 2 + self.lengthString(self.ancestor_.ByteSize())

   620     n += 2 * len(self.filter_)

   621     for i in xrange(len(self.filter_)): n += self.filter_[i].ByteSize()

   622     if (self.has_search_query_): n += 1 + self.lengthString(len(self.search_query_))

   623     n += 2 * len(self.order_)

   624     for i in xrange(len(self.order_)): n += self.order_[i].ByteSize()

   625     if (self.has_hint_): n += 2 + self.lengthVarInt64(self.hint_)

   626     if (self.has_offset_): n += 1 + self.lengthVarInt64(self.offset_)

   627     if (self.has_limit_): n += 2 + self.lengthVarInt64(self.limit_)

   628     n += 2 * len(self.composite_index_)

   629     for i in xrange(len(self.composite_index_)): n += self.lengthString(self.composite_index_[i].ByteSize())

   630     if (self.has_require_perfect_plan_): n += 3

   631     return n + 1

   632 

   633   def Clear(self):

   634     self.clear_app()

   635     self.clear_kind()

   636     self.clear_ancestor()

   637     self.clear_filter()

   638     self.clear_search_query()

   639     self.clear_order()

   640     self.clear_hint()

   641     self.clear_offset()

   642     self.clear_limit()

   643     self.clear_composite_index()

   644     self.clear_require_perfect_plan()

   645 

   646   def OutputUnchecked(self, out):

   647     out.putVarInt32(10)

   648     out.putPrefixedString(self.app_)

   649     if (self.has_kind_):

   650       out.putVarInt32(26)

   651       out.putPrefixedString(self.kind_)

   652     for i in xrange(len(self.filter_)):

   653       out.putVarInt32(35)

   654       self.filter_[i].OutputUnchecked(out)

   655       out.putVarInt32(36)

   656     if (self.has_search_query_):

   657       out.putVarInt32(66)

   658       out.putPrefixedString(self.search_query_)

   659     for i in xrange(len(self.order_)):

   660       out.putVarInt32(75)

   661       self.order_[i].OutputUnchecked(out)

   662       out.putVarInt32(76)

   663     if (self.has_offset_):

   664       out.putVarInt32(96)

   665       out.putVarInt32(self.offset_)

   666     if (self.has_limit_):

   667       out.putVarInt32(128)

   668       out.putVarInt32(self.limit_)

   669     if (self.has_ancestor_):

   670       out.putVarInt32(138)

   671       out.putVarInt32(self.ancestor_.ByteSize())

   672       self.ancestor_.OutputUnchecked(out)

   673     if (self.has_hint_):

   674       out.putVarInt32(144)

   675       out.putVarInt32(self.hint_)

   676     for i in xrange(len(self.composite_index_)):

   677       out.putVarInt32(154)

   678       out.putVarInt32(self.composite_index_[i].ByteSize())

   679       self.composite_index_[i].OutputUnchecked(out)

   680     if (self.has_require_perfect_plan_):

   681       out.putVarInt32(160)

   682       out.putBoolean(self.require_perfect_plan_)

   683 

   684   def TryMerge(self, d):

   685     while d.avail() > 0:

   686       tt = d.getVarInt32()

   687       if tt == 10:

   688         self.set_app(d.getPrefixedString())

   689         continue

   690       if tt == 26:

   691         self.set_kind(d.getPrefixedString())

   692         continue

   693       if tt == 35:

   694         self.add_filter().TryMerge(d)

   695         continue

   696       if tt == 66:

   697         self.set_search_query(d.getPrefixedString())

   698         continue

   699       if tt == 75:

   700         self.add_order().TryMerge(d)

   701         continue

   702       if tt == 96:

   703         self.set_offset(d.getVarInt32())

   704         continue

   705       if tt == 128:

   706         self.set_limit(d.getVarInt32())

   707         continue

   708       if tt == 138:

   709         length = d.getVarInt32()

   710         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)

   711         d.skip(length)

   712         self.mutable_ancestor().TryMerge(tmp)

   713         continue

   714       if tt == 144:

   715         self.set_hint(d.getVarInt32())

   716         continue

   717       if tt == 154:

   718         length = d.getVarInt32()

   719         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)

   720         d.skip(length)

   721         self.add_composite_index().TryMerge(tmp)

   722         continue

   723       if tt == 160:

   724         self.set_require_perfect_plan(d.getBoolean())

   725         continue

   726       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError

   727       d.skipData(tt)

   728 

   729 

   730   def __str__(self, prefix="", printElemNumber=0):

   731     res=""

   732     if self.has_app_: res+=prefix+("app: %s\n" % self.DebugFormatString(self.app_))

   733     if self.has_kind_: res+=prefix+("kind: %s\n" % self.DebugFormatString(self.kind_))

   734     if self.has_ancestor_:

   735       res+=prefix+"ancestor <\n"

   736       res+=self.ancestor_.__str__(prefix + "  ", printElemNumber)

   737       res+=prefix+">\n"

   738     cnt=0

   739     for e in self.filter_:

   740       elm=""

   741       if printElemNumber: elm="(%d)" % cnt

   742       res+=prefix+("Filter%s {\n" % elm)

   743       res+=e.__str__(prefix + "  ", printElemNumber)

   744       res+=prefix+"}\n"

   745       cnt+=1

   746     if self.has_search_query_: res+=prefix+("search_query: %s\n" % self.DebugFormatString(self.search_query_))

   747     cnt=0

   748     for e in self.order_:

   749       elm=""

   750       if printElemNumber: elm="(%d)" % cnt

   751       res+=prefix+("Order%s {\n" % elm)

   752       res+=e.__str__(prefix + "  ", printElemNumber)

   753       res+=prefix+"}\n"

   754       cnt+=1

   755     if self.has_hint_: res+=prefix+("hint: %s\n" % self.DebugFormatInt32(self.hint_))

   756     if self.has_offset_: res+=prefix+("offset: %s\n" % self.DebugFormatInt32(self.offset_))

   757     if self.has_limit_: res+=prefix+("limit: %s\n" % self.DebugFormatInt32(self.limit_))

   758     cnt=0

   759     for e in self.composite_index_:

   760       elm=""

   761       if printElemNumber: elm="(%d)" % cnt

   762       res+=prefix+("composite_index%s <\n" % elm)

   763       res+=e.__str__(prefix + "  ", printElemNumber)

   764       res+=prefix+">\n"

   765       cnt+=1

   766     if self.has_require_perfect_plan_: res+=prefix+("require_perfect_plan: %s\n" % self.DebugFormatBool(self.require_perfect_plan_))

   767     return res

   768 

   769   kapp = 1

   770   kkind = 3

   771   kancestor = 17

   772   kFilterGroup = 4

   773   kFilterop = 6

   774   kFilterproperty = 14

   775   ksearch_query = 8

   776   kOrderGroup = 9

   777   kOrderproperty = 10

   778   kOrderdirection = 11

   779   khint = 18

   780   koffset = 12

   781   klimit = 16

   782   kcomposite_index = 19

   783   krequire_perfect_plan = 20

   784 

   785   _TEXT = (

   786    "ErrorCode",

   787    "app",

   788    None,

   789    "kind",

   790    "Filter",

   791    None,

   792    "op",

   793    None,

   794    "search_query",

   795    "Order",

   796    "property",

   797    "direction",

   798    "offset",

   799    None,

   800    "property",

   801    None,

   802    "limit",

   803    "ancestor",

   804    "hint",

   805    "composite_index",

   806    "require_perfect_plan",

   807   )

   808 

   809   _TYPES = (

   810    ProtocolBuffer.Encoder.NUMERIC,

   811    ProtocolBuffer.Encoder.STRING,

   812 

   813    ProtocolBuffer.Encoder.MAX_TYPE,

   814 

   815    ProtocolBuffer.Encoder.STRING,

   816 

   817    ProtocolBuffer.Encoder.STARTGROUP,

   818 

   819    ProtocolBuffer.Encoder.MAX_TYPE,

   820 

   821    ProtocolBuffer.Encoder.NUMERIC,

   822 

   823    ProtocolBuffer.Encoder.MAX_TYPE,

   824 

   825    ProtocolBuffer.Encoder.STRING,

   826 

   827    ProtocolBuffer.Encoder.STARTGROUP,

   828 

   829    ProtocolBuffer.Encoder.STRING,

   830 

   831    ProtocolBuffer.Encoder.NUMERIC,

   832 

   833    ProtocolBuffer.Encoder.NUMERIC,

   834 

   835    ProtocolBuffer.Encoder.MAX_TYPE,

   836 

   837    ProtocolBuffer.Encoder.STRING,

   838 

   839    ProtocolBuffer.Encoder.MAX_TYPE,

   840 

   841    ProtocolBuffer.Encoder.NUMERIC,

   842 

   843    ProtocolBuffer.Encoder.STRING,

   844 

   845    ProtocolBuffer.Encoder.NUMERIC,

   846 

   847    ProtocolBuffer.Encoder.STRING,

   848 

   849    ProtocolBuffer.Encoder.NUMERIC,

   850 

   851   )

   852 

   853   _STYLE = """"""

   854   _STYLE_CONTENT_TYPE = """"""

   855 class QueryExplanation(ProtocolBuffer.ProtocolMessage):

   856   def __init__(self, contents=None):

   857     self.native_ancestor_ = 0

   858     self.native_index_ = []

   859     self.native_offset_ = 0

   860     self.native_limit_ = 0

   861     self.has_native_ancestor_ = 0

   862     self.has_native_offset_ = 0

   863     self.has_native_limit_ = 0

   864     if contents is not None: self.MergeFromString(contents)

   865 

   866   def native_ancestor(self): return self.native_ancestor_

   867 

   868   def set_native_ancestor(self, x):

   869     self.has_native_ancestor_ = 1

   870     self.native_ancestor_ = x

   871 

   872   def clear_native_ancestor(self):

   873     self.has_native_ancestor_ = 0

   874     self.native_ancestor_ = 0

   875 

   876   def has_native_ancestor(self): return self.has_native_ancestor_

   877 

   878   def native_index_size(self): return len(self.native_index_)

   879   def native_index_list(self): return self.native_index_

   880 

   881   def native_index(self, i):

   882     return self.native_index_[i]

   883 

   884   def mutable_native_index(self, i):

   885     return self.native_index_[i]

   886 

   887   def add_native_index(self):

   888     x = Index()

   889     self.native_index_.append(x)

   890     return x

   891 

   892   def clear_native_index(self):

   893     self.native_index_ = []

   894   def native_offset(self): return self.native_offset_

   895 

   896   def set_native_offset(self, x):

   897     self.has_native_offset_ = 1

   898     self.native_offset_ = x

   899 

   900   def clear_native_offset(self):

   901     self.has_native_offset_ = 0

   902     self.native_offset_ = 0

   903 

   904   def has_native_offset(self): return self.has_native_offset_

   905 

   906   def native_limit(self): return self.native_limit_

   907 

   908   def set_native_limit(self, x):

   909     self.has_native_limit_ = 1

   910     self.native_limit_ = x

   911 

   912   def clear_native_limit(self):

   913     self.has_native_limit_ = 0

   914     self.native_limit_ = 0

   915 

   916   def has_native_limit(self): return self.has_native_limit_

   917 

   918 

   919   def MergeFrom(self, x):

   920     assert x is not self

   921     if (x.has_native_ancestor()): self.set_native_ancestor(x.native_ancestor())

   922     for i in xrange(x.native_index_size()): self.add_native_index().CopyFrom(x.native_index(i))

   923     if (x.has_native_offset()): self.set_native_offset(x.native_offset())

   924     if (x.has_native_limit()): self.set_native_limit(x.native_limit())

   925 

   926   def Equals(self, x):

   927     if x is self: return 1

   928     if self.has_native_ancestor_ != x.has_native_ancestor_: return 0

   929     if self.has_native_ancestor_ and self.native_ancestor_ != x.native_ancestor_: return 0

   930     if len(self.native_index_) != len(x.native_index_): return 0

   931     for e1, e2 in zip(self.native_index_, x.native_index_):

   932       if e1 != e2: return 0

   933     if self.has_native_offset_ != x.has_native_offset_: return 0

   934     if self.has_native_offset_ and self.native_offset_ != x.native_offset_: return 0

   935     if self.has_native_limit_ != x.has_native_limit_: return 0

   936     if self.has_native_limit_ and self.native_limit_ != x.native_limit_: return 0

   937     return 1

   938 

   939   def __eq__(self, other):

   940     return (other is not None) and (other.__class__ == self.__class__) and self.Equals(other)

   941 

   942   def __ne__(self, other):

   943     return not (self == other)

   944 

   945   def IsInitialized(self, debug_strs=None):

   946     initialized = 1

   947     for i in xrange(len(self.native_index_)):

   948       if (not self.native_index_[i].IsInitialized(debug_strs)): initialized=0

   949     return initialized

   950 

   951   def ByteSize(self):

   952     n = 0

   953     if (self.has_native_ancestor_): n += 2

   954     n += 1 * len(self.native_index_)

   955     for i in xrange(len(self.native_index_)): n += self.lengthString(self.native_index_[i].ByteSize())

   956     if (self.has_native_offset_): n += 1 + self.lengthVarInt64(self.native_offset_)

   957     if (self.has_native_limit_): n += 1 + self.lengthVarInt64(self.native_limit_)

   958     return n + 0

   959 

   960   def Clear(self):

   961     self.clear_native_ancestor()

   962     self.clear_native_index()

   963     self.clear_native_offset()

   964     self.clear_native_limit()

   965 

   966   def OutputUnchecked(self, out):

   967     if (self.has_native_ancestor_):

   968       out.putVarInt32(8)

   969       out.putBoolean(self.native_ancestor_)

   970     for i in xrange(len(self.native_index_)):

   971       out.putVarInt32(18)

   972       out.putVarInt32(self.native_index_[i].ByteSize())

   973       self.native_index_[i].OutputUnchecked(out)

   974     if (self.has_native_offset_):

   975       out.putVarInt32(24)

   976       out.putVarInt32(self.native_offset_)

   977     if (self.has_native_limit_):

   978       out.putVarInt32(32)

   979       out.putVarInt32(self.native_limit_)

   980 

   981   def TryMerge(self, d):

   982     while d.avail() > 0:

   983       tt = d.getVarInt32()

   984       if tt == 8:

   985         self.set_native_ancestor(d.getBoolean())

   986         continue

   987       if tt == 18:

   988         length = d.getVarInt32()

   989         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)

   990         d.skip(length)

   991         self.add_native_index().TryMerge(tmp)

   992         continue

   993       if tt == 24:

   994         self.set_native_offset(d.getVarInt32())

   995         continue

   996       if tt == 32:

   997         self.set_native_limit(d.getVarInt32())

   998         continue

   999       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError

  1000       d.skipData(tt)

  1001 

  1002 

  1003   def __str__(self, prefix="", printElemNumber=0):

  1004     res=""

  1005     if self.has_native_ancestor_: res+=prefix+("native_ancestor: %s\n" % self.DebugFormatBool(self.native_ancestor_))

  1006     cnt=0

  1007     for e in self.native_index_:

  1008       elm=""

  1009       if printElemNumber: elm="(%d)" % cnt

  1010       res+=prefix+("native_index%s <\n" % elm)

  1011       res+=e.__str__(prefix + "  ", printElemNumber)

  1012       res+=prefix+">\n"

  1013       cnt+=1

  1014     if self.has_native_offset_: res+=prefix+("native_offset: %s\n" % self.DebugFormatInt32(self.native_offset_))

  1015     if self.has_native_limit_: res+=prefix+("native_limit: %s\n" % self.DebugFormatInt32(self.native_limit_))

  1016     return res

  1017 

  1018   knative_ancestor = 1

  1019   knative_index = 2

  1020   knative_offset = 3

  1021   knative_limit = 4

  1022 

  1023   _TEXT = (

  1024    "ErrorCode",

  1025    "native_ancestor",

  1026    "native_index",

  1027    "native_offset",

  1028    "native_limit",

  1029   )

  1030 

  1031   _TYPES = (

  1032    ProtocolBuffer.Encoder.NUMERIC,

  1033    ProtocolBuffer.Encoder.NUMERIC,

  1034 

  1035    ProtocolBuffer.Encoder.STRING,

  1036 

  1037    ProtocolBuffer.Encoder.NUMERIC,

  1038 

  1039    ProtocolBuffer.Encoder.NUMERIC,

  1040 

  1041   )

  1042 

  1043   _STYLE = """"""

  1044   _STYLE_CONTENT_TYPE = """"""

  1045 class Cursor(ProtocolBuffer.ProtocolMessage):

  1046   def __init__(self, contents=None):

  1047     self.cursor_ = 0

  1048     self.has_cursor_ = 0

  1049     if contents is not None: self.MergeFromString(contents)

  1050 

  1051   def cursor(self): return self.cursor_

  1052 

  1053   def set_cursor(self, x):

  1054     self.has_cursor_ = 1

  1055     self.cursor_ = x

  1056 

  1057   def clear_cursor(self):

  1058     self.has_cursor_ = 0

  1059     self.cursor_ = 0

  1060 

  1061   def has_cursor(self): return self.has_cursor_

  1062 

  1063 

  1064   def MergeFrom(self, x):

  1065     assert x is not self

  1066     if (x.has_cursor()): self.set_cursor(x.cursor())

  1067 

  1068   def Equals(self, x):

  1069     if x is self: return 1

  1070     if self.has_cursor_ != x.has_cursor_: return 0

  1071     if self.has_cursor_ and self.cursor_ != x.cursor_: return 0

  1072     return 1

  1073 

  1074   def __eq__(self, other):

  1075     return (other is not None) and (other.__class__ == self.__class__) and self.Equals(other)

  1076 

  1077   def __ne__(self, other):

  1078     return not (self == other)

  1079 

  1080   def IsInitialized(self, debug_strs=None):

  1081     initialized = 1

  1082     if (not self.has_cursor_):

  1083       initialized = 0

  1084       if debug_strs is not None:

  1085         debug_strs.append('Required field: cursor not set.')

  1086     return initialized

  1087 

  1088   def ByteSize(self):

  1089     n = 0

  1090     return n + 9

  1091 

  1092   def Clear(self):

  1093     self.clear_cursor()

  1094 

  1095   def OutputUnchecked(self, out):

  1096     out.putVarInt32(9)

  1097     out.put64(self.cursor_)

  1098 

  1099   def TryMerge(self, d):

  1100     while d.avail() > 0:

  1101       tt = d.getVarInt32()

  1102       if tt == 9:

  1103         self.set_cursor(d.get64())

  1104         continue

  1105       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError

  1106       d.skipData(tt)

  1107 

  1108 

  1109   def __str__(self, prefix="", printElemNumber=0):

  1110     res=""

  1111     if self.has_cursor_: res+=prefix+("cursor: %s\n" % self.DebugFormatFixed64(self.cursor_))

  1112     return res

  1113 

  1114   kcursor = 1

  1115 

  1116   _TEXT = (

  1117    "ErrorCode",

  1118    "cursor",

  1119   )

  1120 

  1121   _TYPES = (

  1122    ProtocolBuffer.Encoder.NUMERIC,

  1123    ProtocolBuffer.Encoder.DOUBLE,

  1124 

  1125   )

  1126 

  1127   _STYLE = """"""

  1128   _STYLE_CONTENT_TYPE = """"""

  1129 class Error(ProtocolBuffer.ProtocolMessage):

  1130 

  1131   BAD_REQUEST  =    1

  1132   CONCURRENT_TRANSACTION =    2

  1133   INTERNAL_ERROR =    3

  1134   NEED_INDEX   =    4

  1135   TIMEOUT      =    5