java/src/main/com/google/appengine/api/datastore/CloudDatastoreProtoConverter.java

   1 package com.google.appengine.api.datastore;
   2
   3 import static com.google.common.base.Preconditions.checkArgument;
   4
   5 import com.google.api.services.datastore.DatastoreV1;
   6 import com.google.api.services.datastore.DatastoreV1.Key;
   7 import com.google.apphosting.datastore.DatastoreV4;
   8 import com.google.apphosting.datastore.DatastoreV4.AllocateIdsRequestOrBuilder;
   9 import com.google.apphosting.datastore.DatastoreV4.AllocateIdsResponse;
  10 import com.google.apphosting.datastore.DatastoreV4.BeginTransactionResponse;
  11 import com.google.apphosting.datastore.DatastoreV4.CommitRequestOrBuilder;
  12 import com.google.apphosting.datastore.DatastoreV4.CommitResponse;
  13 import com.google.apphosting.datastore.DatastoreV4.DeprecatedMutation;
  14 import com.google.apphosting.datastore.DatastoreV4.EntityResult;
  15 import com.google.apphosting.datastore.DatastoreV4.GqlQuery;
  16 import com.google.apphosting.datastore.DatastoreV4.LookupRequestOrBuilder;
  17 import com.google.apphosting.datastore.DatastoreV4.LookupResponse;
  18 import com.google.apphosting.datastore.DatastoreV4.Mutation;
  19 import com.google.apphosting.datastore.DatastoreV4.MutationResult;
  20 import com.google.apphosting.datastore.DatastoreV4.QueryResultBatch;
  21 import com.google.apphosting.datastore.DatastoreV4.ReadOptions;
  22 import com.google.apphosting.datastore.DatastoreV4.RollbackRequestOrBuilder;
  23 import com.google.apphosting.datastore.DatastoreV4.RunQueryRequestOrBuilder;
  24 import com.google.apphosting.datastore.DatastoreV4.RunQueryResponse;
  25 import com.google.apphosting.datastore.EntityV4;
  26 import com.google.apphosting.datastore.EntityV4.PartitionId;
  27 import com.google.protobuf.InvalidProtocolBufferException;
  28 import com.google.protobuf.Message;
  29 import com.google.protobuf.Parser;
  30
  31 import java.util.Iterator;
  32 import java.util.Set;
  33
  34 /**
  35  * This class converts corresponding protos between DatastoreV4 and DatastoreV1.
  36  */
  37 class CloudDatastoreProtoConverter {
  38   private static final CloudDatastoreProtoConverter INSTANCE =
  39       new CloudDatastoreProtoConverter();
  40
  41   static CloudDatastoreProtoConverter getInstance() {
  42     return INSTANCE;
  43   }
  44
  45   private CloudDatastoreProtoConverter() {}
  46
  47   BeginTransactionResponse.Builder toV4BeginTransactionResponse(
  48       DatastoreV1.BeginTransactionResponseOrBuilder v1Response) {
  49     return BeginTransactionResponse.newBuilder()
  50         .setTransaction(v1Response.getTransaction());
  51   }
  52
  53   DatastoreV1.RollbackRequest.Builder toV1RollbackRequest(
  54       RollbackRequestOrBuilder v4Request) {
  55     return DatastoreV1.RollbackRequest.newBuilder()
  56         .setTransaction(v4Request.getTransaction());
  57   }
  58
  59   DatastoreV1.RunQueryRequest.Builder toV1RunQueryRequest(
  60       RunQueryRequestOrBuilder v4Request) {
  61     DatastoreV1.RunQueryRequest.Builder v1Request = DatastoreV1.RunQueryRequest.newBuilder();
  62     if (v4Request.hasReadOptions()) {
  63       v1Request.setReadOptions(toV1ReadOptions(v4Request.getReadOptions()));
  64     }
  65     if (v4Request.hasPartitionId()) {
  66       v1Request.setPartitionId(toV1PartitionId(v4Request.getPartitionId()));
  67     }
  68     if (v4Request.hasQuery()) {
  69       v1Request.setQuery(toV1Query(v4Request.getQuery()));
  70     }
  71     if (v4Request.hasGqlQuery()) {
  72       v1Request.setGqlQuery(toV1GqlQuery(v4Request.getGqlQuery()));
  73     }
  74     return v1Request;
  75   }
  76
  77   RunQueryResponse.Builder toV4RunQueryResponse(
  78       DatastoreV1.RunQueryResponseOrBuilder v1Response) {
  79     return RunQueryResponse.newBuilder()
  80         .setBatch(toV4QueryResultBatch(v1Response.getBatch()));
  81   }
  82
  83   DatastoreV1.LookupRequest.Builder toV1LookupRequest(LookupRequestOrBuilder v4Request) {
  84     DatastoreV1.LookupRequest.Builder v1Request = DatastoreV1.LookupRequest.newBuilder();
  85     if (v4Request.hasReadOptions()) {
  86       v1Request.setReadOptions(toV1ReadOptions(v4Request.getReadOptions()));
  87     }
  88     for (EntityV4.Key v4Key : v4Request.getKeyList()) {
  89       v1Request.addKey(toV1Key(v4Key));
  90     }
  91     return v1Request;
  92   }
  93
  94   LookupResponse.Builder toV4LookupResponse(DatastoreV1.LookupResponseOrBuilder v1Response) {
  95     LookupResponse.Builder v4Response = LookupResponse.newBuilder();
  96     for (DatastoreV1.EntityResult v1FoundResult : v1Response.getFoundList()) {
  97       v4Response.addFound(toV4EntityResult(v1FoundResult));
  98     }
  99     for (DatastoreV1.EntityResult v1MissingResult : v1Response.getMissingList()) {
 100       v4Response.addMissing(toV4EntityResult(v1MissingResult));
 101     }
 102     for (DatastoreV1.Key v1DeferredKey : v1Response.getDeferredList()) {
 103       v4Response.addDeferred(toV4Key(v1DeferredKey));
 104     }
 105     return v4Response;
 106   }
 107
 108   DatastoreV1.AllocateIdsRequest.Builder toV1AllocateIdsRequest(
 109       AllocateIdsRequestOrBuilder v4Request) {
 110     checkArgument(v4Request.getReserveCount() == 0, "V1 does not support reserve.");
 111     DatastoreV1.AllocateIdsRequest.Builder v1Request = DatastoreV1.AllocateIdsRequest.newBuilder();
 112     for (EntityV4.Key v4Key : v4Request.getAllocateList()) {
 113       v1Request.addKey(toV1Key(v4Key));
 114     }
 115     return v1Request;
 116   }
 117
 118   AllocateIdsResponse.Builder toV4AllocateIdsResponse(
 119       DatastoreV1.AllocateIdsResponseOrBuilder v1Response) {
 120     AllocateIdsResponse.Builder v4Response = AllocateIdsResponse.newBuilder();
 121     for (DatastoreV1.Key v1Key : v1Response.getKeyList()) {
 122       v4Response.addAllocated(toV4Key(v1Key));
 123     }
 124     return v4Response;
 125   }
 126
 127   DatastoreV1.CommitRequest.Builder toV1CommitRequest(CommitRequestOrBuilder v4Request) {
 128     DatastoreV1.CommitRequest.Builder v1Request = DatastoreV1.CommitRequest.newBuilder();
 129     if (v4Request.hasTransaction()) {
 130       v1Request.setTransaction(v4Request.getTransaction());
 131     }
 132     checkArgument(!v4Request.hasDeprecatedMutation(), "Deprecated mutations are not supported.");
 133     if (v4Request.getMutationCount() != 0) {
 134       DatastoreV1.Mutation.Builder v1Mutations = v1Request.getMutationBuilder();
 135       for (Mutation v4Mutation : v4Request.getMutationList()) {
 136         switch (v4Mutation.getOp()) {
 137           case DELETE:
 138             if (!v4Mutation.hasKey()) {
 139               throw new IllegalArgumentException();
 140             }
 141             v1Mutations.addDelete(toV1Key(v4Mutation.getKey()));
 142             break;
 143           case INSERT:
 144             throw new IllegalArgumentException();
 145           case UPDATE:
 146             if (!v4Mutation.hasEntity()) {
 147               throw new IllegalArgumentException();
 148             }
 149             v1Mutations.addUpdate(toV1Entity(v4Mutation.getEntity()));
 150             break;
 151           case UPSERT:
 152             if (!v4Mutation.hasEntity()) {
 153               throw new IllegalArgumentException();
 154             }
 155             v1Mutations.addUpsert(toV1Entity(v4Mutation.getEntity()));
 156             break;
 157           case UNKNOWN:
 158           default:
 159             throw new IllegalArgumentException();
 160         }
 161       }
 162     }
 163     if (v4Request.hasMode()) {
 164       v1Request.setMode(DatastoreV1.CommitRequest.Mode.valueOf(v4Request.getMode().getNumber()));
 165     }
 166     return v1Request;
 167   }
 168
 169   CommitResponse.Builder toV4CommitResponse(DatastoreV1.CommitResponseOrBuilder v1Response,
 170       CommitRequestOrBuilder v4Request) {
 171     CommitResponse.Builder v4Response = CommitResponse.newBuilder();
 172     if (v4Request.getMutationCount() != 0) {
 173       DatastoreV1.MutationResult v1MutationResult = v1Response.getMutationResult();
 174       Iterator<Key> allocatedIdKeyIt = v1MutationResult.getInsertAutoIdKeyList().iterator();
 175       for (Mutation v4Mutation : v4Request.getMutationList()) {
 176         MutationResult.Builder v4MutationResult = v4Response.addMutationResultBuilder();
 177         if (v4Mutation.getOp() == Mutation.Operation.UPSERT) {
 178           EntityV4.Key v4RequestKey = v4Mutation.getEntity().getKey();
 179           EntityV4.Key.PathElement v4ReqPathElt =
 180               v4RequestKey.getPathElement(v4RequestKey.getPathElementCount() - 1);
 181           if (!v4ReqPathElt.hasId() && !v4ReqPathElt.hasName()) {
 182             v4MutationResult.setKey(toV4Key(allocatedIdKeyIt.next()));
 183           }
 184         }
 185       }
 186       if (allocatedIdKeyIt.hasNext()) {
 187         throw new IllegalArgumentException("Too many allocated keys.");
 188       }
 189       if (v1MutationResult.hasIndexUpdates()) {
 190         v4Response.setIndexUpdates(v1MutationResult.getIndexUpdates());
 191       }
 192     }
 193     return v4Response;
 194   }
 195
 196   static DatastoreV1.Mutation toV1Mutation(DeprecatedMutation v4DeprecatedMutation) {
 197     return checkedProtoConversion(DatastoreV1.Mutation.PARSER, v4DeprecatedMutation);
 198   }
 199
 200   static MutationResult toV4MutationResult(DatastoreV1.MutationResult v1MutationResult) {
 201     return checkedProtoConversion(MutationResult.PARSER, v1MutationResult);
 202   }
 203
 204   static QueryResultBatch toV4QueryResultBatch(DatastoreV1.QueryResultBatch v1QueryResultBatch) {
 205     return checkedProtoConversion(DatastoreV4.QueryResultBatch.PARSER, v1QueryResultBatch);
 206   }
 207
 208   static DatastoreV1.PartitionId toV1PartitionId(PartitionId v4PartitionId) {
 209     return checkedProtoConversion(DatastoreV1.PartitionId.PARSER, v4PartitionId);
 210   }
 211
 212   static DatastoreV1.ReadOptions toV1ReadOptions(ReadOptions v4ReadOptions) {
 213     return checkedProtoConversion(DatastoreV1.ReadOptions.PARSER, v4ReadOptions);
 214   }
 215
 216   static DatastoreV1.GqlQuery toV1GqlQuery(GqlQuery v4GqlQuery) {
 217     return checkedProtoConversion(DatastoreV1.GqlQuery.PARSER, v4GqlQuery);
 218   }
 219
 220   static DatastoreV1.Query toV1Query(DatastoreV4.Query v4Query) {
 221     return checkedProtoConversion(DatastoreV1.Query.PARSER, v4Query);
 222   }
 223
 224   static DatastoreV1.Entity toV1Entity(EntityV4.Entity v4Entity) {
 225     return checkedProtoConversion(DatastoreV1.Entity.PARSER, v4Entity);
 226   }
 227
 228   static EntityResult toV4EntityResult(DatastoreV1.EntityResult v1EntityResult) {
 229     return checkedProtoConversion(EntityResult.PARSER, v1EntityResult);
 230   }
 231
 232   static DatastoreV1.Key toV1Key(EntityV4.Key v4Key) {
 233     return checkedProtoConversion(DatastoreV1.Key.PARSER, v4Key);
 234   }
 235
 236   static EntityV4.Key toV4Key(DatastoreV1.Key v1Key) {
 237     return checkedProtoConversion(EntityV4.Key.PARSER, v1Key);
 238   }
 239
 240   private static <T extends Message> T checkedProtoConversion(Parser<T> parser, Message source) {
 241     try {
 242       T result = parser.parseFrom(source.toByteArray());
 243       Set<String> unknownFields = new UnknownFieldChecker().getUnknownFields(result);
 244       if (!unknownFields.isEmpty()) {
 245         throw new IllegalArgumentException("Conversion from [" + source + "] has unknown fields:\n"
 246             + unknownFields);
 247       }
 248       return result;
 249     } catch (InvalidProtocolBufferException e) {
 250       throw new RuntimeException(e);
 251     }
 252   }
 253 }