java/src/main/com/google/appengine/api/search/Schema.java

   1 // Copyright 2011 Google Inc. All Rights Reserved.
   2
   3 package com.google.appengine.api.search;
   4
   5 import com.google.appengine.api.search.checkers.FieldChecker;
   6 import com.google.apphosting.api.search.DocumentPb;
   7
   8 import java.util.ArrayList;
   9 import java.util.Collections;
  10 import java.util.HashMap;
  11 import java.util.List;
  12 import java.util.Map;
  13 import java.util.Set;
  14
  15 /**
  16  * Contains information about the kinds of document {@link Field Fields}
  17  * which are supported by the {@link Index}.
  18  * <p>
  19  * <pre>
  20  *   // Get the searchService for the default namespace
  21  *   SearchService searchService = SearchServiceFactory.getSearchService();
  22  *
  23  *   // Get the first page of indexes available and retrieve schemas
  24  *   GetResponse<Index> response = searchService.getIndexes(
  25  *       GetIndexesRequest.newBuilder().setSchemaFetched(true).build());
  26  *
  27  *   // List out elements of Schema
  28  *   for (Index index : response) {
  29  *     Schema schema = index.getSchema();
  30  *     for (String fieldName : schema.getFieldNames()) {
  31  *        List<FieldType> typesForField = schema.getFieldTypes(fieldName);
  32  *     }
  33  *   }
  34  * </pre>
  35  *
  36  */
  37 public final class Schema {
  38
  39   /**
  40    * A builder which constructs Schema objects.
  41    */
  42   public static final class Builder {
  43     private final Map<String, List<Field.FieldType>> fieldMap =
  44         new HashMap<String, List<Field.FieldType>>();
  45
  46     /**
  47      * Constructs a builder for a schema.
  48      */
  49     protected Builder() {
  50     }
  51
  52     /**
  53      * Adds typed field name to the schema builder. Allows multiple
  54      * field types with the same name.
  55      *
  56      * @param fieldName the field name to add to the schema
  57      * @return this document builder
  58      */
  59     public Builder addTypedField(String fieldName, Field.FieldType fieldType) {
  60       FieldChecker.checkFieldName(fieldName);
  61       List<Field.FieldType> types = fieldMap.get(fieldName);
  62       if (types == null) {
  63         types = new ArrayList<Field.FieldType>();
  64         fieldMap.put(fieldName, types);
  65       }
  66       types.add(fieldType);
  67       return this;
  68     }
  69
  70     /**
  71      * Builds a valid document. The builder must have set a valid document
  72      * id, and have a non-empty set of valid fields.
  73      *
  74      * @return the schema built by this builder
  75      * @throws IllegalArgumentException if the document built is not valid
  76      */
  77     public Schema build() {
  78       return new Schema(this);
  79     }
  80   }
  81
  82   private final Map<String, List<Field.FieldType>> fieldMap;
  83
  84   /**
  85    * Creates a {@link Schema} from a {@link Builder}.
  86    *
  87    * @param builder the builder
  88    */
  89   private Schema(Builder builder) {
  90     this.fieldMap = Collections.unmodifiableMap(builder.fieldMap);
  91   }
  92
  93   /**
  94    * @return the set of field names supported in the schema
  95    */
  96   public Set<String> getFieldNames() {
  97     return fieldMap.keySet();
  98   }
  99
 100   /**
 101    * @param fieldName the name of the field to return supported types
 102    * @return a list of {@link Field.FieldType} supported for the given field
 103    * name. The returned list will be empty if the schema has no field with the given name.
 104    */
 105   public List<Field.FieldType> getFieldTypes(String fieldName) {
 106     List<Field.FieldType> fieldTypes = fieldMap.get(fieldName);
 107     if (fieldTypes != null) {
 108       return Collections.unmodifiableList(fieldTypes);
 109     }
 110     return Collections.emptyList();
 111   }
 112
 113   @Override
 114   public String toString() {
 115     return String.format("Schema{fieldMap: %s}", fieldMap);
 116   }
 117
 118   /**
 119    * Maps between DocumentPb.FieldValue.ContentType enums and the public
 120    * Field.FieldType.
 121    */
 122   static Field.FieldType mapPBFieldTypeToPublic(DocumentPb.FieldValue.ContentType type) {
 123     switch (type) {
 124       case TEXT:
 125         return Field.FieldType.TEXT;
 126       case HTML:
 127         return Field.FieldType.HTML;
 128       case ATOM:
 129         return Field.FieldType.ATOM;
 130       case DATE:
 131         return Field.FieldType.DATE;
 132       case NUMBER:
 133         return Field.FieldType.NUMBER;
 134       case GEO:
 135         return Field.FieldType.GEO_POINT;
 136       default:
 137         throw new IllegalArgumentException("Unsupported field type " + type);
 138     }
 139   }
 140
 141   /**
 142    * Maps between public Field.Field enums and the protocol buffer
 143    * TypeDocumentPb.FieldValue.ContentType enums.
 144    */
 145   static DocumentPb.FieldValue.ContentType mapPublicFieldTypeToPB(Field.FieldType type) {
 146     switch (type) {
 147       case TEXT:
 148         return DocumentPb.FieldValue.ContentType.TEXT;
 149       case HTML:
 150         return DocumentPb.FieldValue.ContentType.HTML;
 151       case ATOM:
 152         return DocumentPb.FieldValue.ContentType.ATOM;
 153       case DATE:
 154         return DocumentPb.FieldValue.ContentType.DATE;
 155       case NUMBER:
 156         return DocumentPb.FieldValue.ContentType.NUMBER;
 157       case GEO_POINT:
 158         return DocumentPb.FieldValue.ContentType.GEO;
 159       default:
 160         throw new IllegalArgumentException("Unsupported field type " + type);
 161     }
 162   }
 163
 164   /**
 165    * Creates a {@link Schema} from a {@link SearchServicePb.IndexMetadata}.
 166    *
 167    * @param metadata the proto buffer containing supported field names
 168    * and types.
 169    * @return a {@link Schema} containing supported field names and field
 170    * types for those names
 171    */
 172   static Schema createSchema(SearchServicePb.IndexMetadata metadata) {
 173     if (metadata.getFieldCount() == 0) {
 174       return null;
 175     }
 176     Map<String, List<Field.FieldType>> fieldMap = new HashMap<String, List<Field.FieldType>>();
 177     Builder builder = newBuilder();
 178     for (DocumentPb.FieldTypes fieldTypes : metadata.getFieldList()) {
 179       String fieldName = fieldTypes.getName();
 180       for (DocumentPb.FieldValue.ContentType type : fieldTypes.getTypeList()) {
 181         builder.addTypedField(fieldName, mapPBFieldTypeToPublic(type));
 182       }
 183     }
 184     return builder.build();
 185   }
 186
 187   @Override
 188   public int hashCode() {
 189     return fieldMap.hashCode();
 190   }
 191
 192   @Override
 193   public boolean equals(Object obj) {
 194     if (this == obj) {
 195       return true;
 196     }
 197     if (obj == null) {
 198       return false;
 199     }
 200     if (getClass() != obj.getClass()) {
 201       return false;
 202     }
 203     return fieldMap.equals(((Schema) obj).fieldMap);
 204   }
 205
 206   /**
 207    * Creates a schema builder.
 208    *
 209    * @return a new builder for creating a schema
 210    */
 211   public static Builder newBuilder() {
 212     return new Builder();
 213   }
 214 }