import org.apache.gora.persistency.impl.PersistentBase; //导入依赖的package包/类
private BasicDBObject recordToMongo(final String docf,
    final Schema fieldSchema, final Object value) {
  BasicDBObject record = new BasicDBObject();
  for (Field member : fieldSchema.getFields()) {
    Object innerValue = ((PersistentBase) value).get(member.pos());
    String innerDoc = mapping.getDocumentField(member.name());
    Type innerType = member.schema().getType();
    DocumentFieldType innerStoreType = mapping.getDocumentFieldType(innerDoc);
    LOG.debug(
        "Transform value to DBObject (RECORD), docField:{}, schemaType:{}, storeType:{}",
        new Object[] { member.name(), member.schema().getType(),
            innerStoreType });
    record.put(
        member.name(),
        toDBObject(docf, member.schema(), innerType, innerStoreType,
            innerValue));
  }
  return record;
}
 

import org.apache.gora.persistency.impl.PersistentBase; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public static <K, T extends Persistent> IDynamoDB<K, T> buildDynamoDBStore(
    DynamoDBUtils.DynamoDBType serType) {
  final IDynamoDB<K, T> ds;
  switch (serType) {
    case DYNAMO:
      ds = new DynamoDBNativeStore<K, T>();
      LOG.debug("Using DynamoDB based serialization mode.");
      break;
    case AVRO:
      ds = (IDynamoDB<K, T>) new DynamoDBAvroStore<K, PersistentBase>();
      LOG.debug("Using Avro based serialization mode.");
      break;
    default:
      throw new IllegalStateException("Serialization mode not supported.");
  }
  return ds;
}
 

import org.apache.gora.persistency.impl.PersistentBase; //导入依赖的package包/类
/**
 * Returns a clone with exactly the requested fields shallowly copied
 */
private static<T extends PersistentBase> T getPersistent(T obj, String[] fields) {
  List<Field> otherFields = obj.getSchema().getFields();
  String[] otherFieldStrings = new String[otherFields.size()];
  for(int i = 0; i<otherFields.size(); i++ ){
    otherFieldStrings[i] = otherFields.get(i).name();
  }
  if(Arrays.equals(fields, otherFieldStrings)) { 
    return obj;
  }
  T newObj = AvroUtils.deepClonePersistent(obj);
  newObj.clear();
  for (String field : fields) {
    Field otherField = obj.getSchema().getField(field);
    int index = otherField.pos();
    newObj.put(index, obj.get(index));
  }
  return newObj;
}
 

import org.apache.gora.persistency.impl.PersistentBase; //导入依赖的package包/类
static void processKeys(CassandraMapping cassandraMapping, Object key, List<String> keys, List<Object> values) {
  CassandraKey cassandraKey = cassandraMapping.getCassandraKey();
  if (cassandraKey != null) {
    if (key instanceof PersistentBase) {
      PersistentBase keyBase = (PersistentBase) key;
      for (Schema.Field field : keyBase.getSchema().getFields()) {
        Field mappedField = cassandraKey.getFieldFromFieldName(field.name());
        if (mappedField != null) {
          keys.add(field.name());
          Object value = keyBase.get(field.pos());
          value = getFieldValueFromAvroBean(field.schema(), field.schema().getType(), value, mappedField);
          values.add(value);
        } else {
          LOG.debug("Ignoring field {}, Since field couldn't find in the {} mapping", new Object[]{field.name(), cassandraMapping.getPersistentClass()});
        }
      }
    } else {
      LOG.error("Key bean isn't extended by {} .", new Object[]{cassandraMapping.getKeyClass(), PersistentBase.class});
    }
  } else {
    keys.add(cassandraMapping.getInlinedDefinedPartitionKey().getFieldName());
    values.add(key);
  }
}
 

import org.apache.gora.persistency.impl.PersistentBase; //导入依赖的package包/类
/**
 * {@inheritDoc}
 *
 * @throws Exception
 */
protected void analyzePersistent() throws Exception {
  userDefineTypeMaps = new HashMap<>();
  for (Field field : mapping.getFieldList()) {
    String fieldType = field.getType();
    if (fieldType.contains("frozen")) {
      String udtType = fieldType.substring(fieldType.indexOf("<") + 1, fieldType.indexOf(">"));
      if (PersistentBase.class.isAssignableFrom(persistentClass)) {
        Schema fieldSchema = persistentSchema.getField(field.getFieldName()).schema();
        if (fieldSchema.getType().equals(Schema.Type.UNION)) {
          for (Schema currentSchema : fieldSchema.getTypes()) {
            if (currentSchema.getType().equals(Schema.Type.RECORD)) {
              fieldSchema = currentSchema;
              break;
            }
          }
        }
        String createQuery = CassandraQueryFactory.getCreateUDTTypeForAvro(mapping, udtType, fieldSchema);
        userDefineTypeMaps.put(udtType, createQuery);
      } else {
        throw new RuntimeException("Unsupported Class for User Define Types, Please use PersistentBase class. field : " + udtType);
      }
    }
  }
}
 

import org.apache.gora.persistency.impl.PersistentBase; //导入依赖的package包/类
/**
 * This method wraps result set data in to DataEntry and creates a list of DataEntry.
 **/
private void populateValuesToPersistent(AbstractGettableData row, ColumnDefinitions columnDefinitions, PersistentBase base, String[] fields) {
  Object paramValue;
  for (String fieldName : fields) {
    Schema.Field avroField = base.getSchema().getField(fieldName);
    Field field = mapping.getFieldFromFieldName(fieldName);
    //to ignore unspecified fields in the mapping
    if (field == null || avroField == null) {
      continue;
    }
    Schema fieldSchema = avroField.schema();
    String columnName = field.getColumnName();
    paramValue = getValue(row, columnDefinitions.getType(columnName), columnName, fieldSchema);
    Object value = AvroCassandraUtils.getAvroFieldValue(paramValue, fieldSchema);
    base.put(avroField.pos(), value);
  }
}
 

import org.apache.gora.persistency.impl.PersistentBase; //导入依赖的package包/类
private Object fromCouchDBRecord(final Schema fieldSchema, final String docf, final Object value) {

    final Object innerValue = ((Map) value).get(docf);
    if (innerValue == null) {
      return null;
    }

    Class<?> clazz = null;
    try {
      clazz = ClassLoadingUtils.loadClass(fieldSchema.getFullName());
    } catch (ClassNotFoundException e) {
      LOG.debug(e.getMessage());
    }

    final PersistentBase record = (PersistentBase) new BeanFactoryImpl(keyClass, clazz).newPersistent();

    for (Field recField : fieldSchema.getFields()) {
      Schema innerSchema = recField.schema();

      record.put(recField.pos(), fromDBObject(innerSchema, recField, recField.name(), innerValue));
    }
    return record;
  }
 

import org.apache.gora.persistency.impl.PersistentBase; //导入依赖的package包/类
private Object convertAvroBeanToOrientDoc(final Schema fieldSchema,
                                          final ODocument doc) {
  Object result;
  Class<?> clazz = null;
  try {
    clazz = ClassLoadingUtils.loadClass(fieldSchema.getFullName());
  } catch (ClassNotFoundException e) {
    //Ignore
  }
  PersistentBase record = (PersistentBase) new BeanFactoryImpl(keyClass, clazz).newPersistent();
  for (Schema.Field recField : fieldSchema.getFields()) {
    Schema innerSchema = recField.schema();
    OrientDBMapping.DocumentFieldType innerStoreType = orientDBMapping
            .getDocumentFieldType(recField.name());
    String innerDocField = orientDBMapping.getDocumentField(recField.name()) != null ? orientDBMapping
            .getDocumentField(recField.name()) : recField.name();
    LOG.debug("Load from ODocument (RECORD), field:{}, schemaType:{}, docField:{}, storeType:{}",
            new Object[]{recField.name(), innerSchema.getType(), innerDocField,
                    innerStoreType});
    record.put(recField.pos(),
            convertDocFieldToAvroField(innerSchema, innerStoreType, recField, innerDocField,
                    doc));
  }
  result = record;
  return result;
}
 

import org.apache.gora.persistency.impl.PersistentBase; //导入依赖的package包/类
public Persistent clone(Persistent persistent, Schema schema) {
  Persistent cloned = (PersistentBase)persistent.newInstance(new StateManagerImpl());
  List<Field> fields = schema.getFields();
  for(Field field: fields) {
    int pos = field.pos();
    switch(field.schema().getType()) {
      case MAP    :
      case ARRAY  :
      case RECORD : 
      case STRING : ((PersistentBase)cloned).put(pos, cloneObject(
          field.schema(), ((PersistentBase)persistent).get(pos), ((PersistentBase)cloned).get(pos))); break;
      case NULL   : break;
      default     : ((PersistentBase)cloned).put(pos, ((PersistentBase)persistent).get(pos)); break;
    }
  }
  
  return cloned;
}
 

import org.apache.gora.persistency.impl.PersistentBase; //导入依赖的package包/类
public static <K, T extends PersistentBase>
InsertUpdateStatement<K, T> createStatement(SqlStore<K, T> store,
    SqlMapping mapping, DBVendor dbVendor) {
  switch(dbVendor) {
    case MYSQL:
      return new MySqlInsertUpdateStatement<K, T>(store, mapping, mapping.getTableName());
    case HSQL:
      return new HSqlInsertUpdateStatement<K, T>(store, mapping, mapping.getTableName());
    case GENERIC:
    default :
      throw new RuntimeException("Database is not supported yet.");    
  }
}
 

import org.apache.gora.persistency.impl.PersistentBase; //导入依赖的package包/类
/**
 * Do the serialization of the {@link PersistentBase} object
 *
 * @param persistent {@link PersistentBase} object to serialize
 * @throws IOException if there is an error during serialization
 */
@Override
public void serialize(PersistentBase persistent) throws IOException {
  datumWriter.setSchema(persistent.getSchema());
  datumWriter.write(persistent, encoder);
  encoder.writeFixed(persistent.getDirtyBytes().array());
}
 

import org.apache.gora.persistency.impl.PersistentBase; //导入依赖的package包/类
public PersistentDeserializer(Class<? extends PersistentBase> c, boolean reuseObjects) {
  this.persistentClass = c;
  this.reuseObjects = reuseObjects;
  try {
    Schema schema = AvroUtils.getSchema(persistentClass);
    datumReader = new SpecificDatumReader<PersistentBase>(schema);

  } catch (Exception ex) {
    throw new RuntimeException(ex);
  }
}
 

import org.apache.gora.persistency.impl.PersistentBase; //导入依赖的package包/类
@Override
public PersistentBase deserialize(PersistentBase persistent) throws IOException {
  persistent = datumReader.read(reuseObjects ? persistent : null, decoder);
  byte[] __g__dirty = new byte[persistent.getFieldsCount()];
  decoder.readFixed(__g__dirty);
  persistent.setDirtyBytes(java.nio.ByteBuffer.wrap(__g__dirty));
  return persistent;
}
 

import org.apache.gora.persistency.impl.PersistentBase; //导入依赖的package包/类
AvroSerializer(CassandraClient cassandraClient, DataStore<K, T> dataStore, CassandraMapping mapping) {
  super(cassandraClient, dataStore.getKeyClass(), dataStore.getPersistentClass(), mapping);
  if (PersistentBase.class.isAssignableFrom(dataStore.getPersistentClass())) {
    persistentSchema = ((PersistentBase) dataStore.getBeanFactory().getCachedPersistent()).getSchema();
  } else {
    throw new RuntimeException("Unsupported persistent class, couldn't able to find the Avro schema.");
  }
  this.cassandraDataStore = dataStore;
  try {
    analyzePersistent();
  } catch (Exception e) {
    throw new RuntimeException("Error occurred while analyzing the persistent class, :" + e.getMessage());
  }
}
 

import org.apache.gora.persistency.impl.PersistentBase; //导入依赖的package包/类
private Map<String, Object> recordToCouchDB(final Schema fieldSchema, final Object fieldValue) {
  final PersistentBase persistent = (PersistentBase) fieldValue;
  final Map<String, Object> newMap = new LinkedHashMap<>();

  if (persistent != null) {
    for (Field member : fieldSchema.getFields()) {
      Schema memberSchema = member.schema();
      Object memberValue = persistent.get(member.pos());
      newMap.put(member.name(), toDBObject(memberSchema, memberValue));
    }
    return newMap;
  }
  return null;
}
 

import org.apache.gora.persistency.impl.PersistentBase; //导入依赖的package包/类
@SuppressWarnings({ "unchecked", "rawtypes" })
private Object fromMongoRecord(final Schema fieldSchema, final String docf,
    final DBObject rec) {
  Object result;
  BSONDecorator innerBson = new BSONDecorator(rec);
  Class<?> clazz = null;
  try {
    clazz = ClassLoadingUtils.loadClass(fieldSchema.getFullName());
  } catch (ClassNotFoundException e) {
  }
  PersistentBase record = (PersistentBase) new BeanFactoryImpl(keyClass, clazz).newPersistent();
  for (Field recField : fieldSchema.getFields()) {
    Schema innerSchema = recField.schema();
    DocumentFieldType innerStoreType = mapping
        .getDocumentFieldType(innerSchema.getName());
    String innerDocField = mapping.getDocumentField(recField.name()) != null ? mapping
        .getDocumentField(recField.name()) : recField.name();
        String fieldPath = docf + "." + innerDocField;
        LOG.debug(
            "Load from DBObject (RECORD), field:{}, schemaType:{}, docField:{}, storeType:{}",
            new Object[] { recField.name(), innerSchema.getType(), fieldPath,
                innerStoreType });
        record.put(
            recField.pos(),
            fromDBObject(innerSchema, innerStoreType, recField, innerDocField,
                innerBson));
  }
  result = record;
  return result;
}
 

import org.apache.gora.persistency.impl.PersistentBase; //导入依赖的package包/类
/**
 * Returns a clone with exactly the requested fields shallowly copied
 */
@SuppressWarnings("unchecked")
private static<T extends Persistent> T getPersistent(T obj, String[] fields) {
  if(Arrays.equals(fields, obj.getFields())) {
    return obj;
  }
  T newObj = (T) obj.newInstance(new StateManagerImpl());
  for(String field:fields) {
    int index = newObj.getFieldIndex(field);
    ((PersistentBase)newObj).put(index, ((PersistentBase)obj).get(index));
  }
  return newObj;
}
 

import org.apache.gora.persistency.impl.PersistentBase; //导入依赖的package包/类
@Override
public void serialize(PersistentBase persistent) throws IOException {   
  datumWriter.setSchema(persistent.getSchema());
  datumWriter.setPersistent(persistent);
      
  datumWriter.write(persistent, encoder);
}
 

import org.apache.gora.persistency.impl.PersistentBase; //导入依赖的package包/类
public PersistentDeserializer(Class<? extends PersistentBase> c, boolean reuseObjects) {
  this.persistentClass = c;
  this.reuseObjects = reuseObjects;
  try {
    Schema schema = AvroUtils.getSchema(persistentClass);
    datumReader = new PersistentDatumReader<PersistentBase>(schema, true);

  } catch (Exception ex) {
    throw new RuntimeException(ex);
  }
}
 

import org.apache.gora.persistency.impl.PersistentBase; //导入依赖的package包/类
/**
 * Serializes the field object using the datumWriter.
 */
public static<T extends PersistentBase> void serialize(OutputStream os,
    PersistentDatumWriter<T> datumWriter, Schema schema, Object object)
    throws IOException {

  BinaryEncoder encoder = new BinaryEncoder(os);
  datumWriter.write(schema, object, encoder);
  encoder.flush();
}