/**
* Convenience accessor for the names of the fields that are dirty.
*
* @return Names of the dirty fields
*/
public String[] getDirtyFieldNames() {
int[] dirtyFieldNumbers = ClassUtils.getFlagsSetTo(dirtyFields, true);
if (dirtyFieldNumbers != null && dirtyFieldNumbers.length > 0) {
String[] dirtyFieldNames = new String[dirtyFieldNumbers.length];
for (int i = 0; i < dirtyFieldNumbers.length; i++) {
dirtyFieldNames[i] =
cmd.getMetaDataForManagedMemberAtAbsolutePosition(dirtyFieldNumbers[i]).getName();
}
return dirtyFieldNames;
}
return null;
}
/**
* Convenience accessor for the names of the fields that are loaded.
*
* @return Names of the loaded fields
*/
public String[] getLoadedFieldNames() {
int[] loadedFieldNumbers = ClassUtils.getFlagsSetTo(loadedFields, true);
if (loadedFieldNumbers != null && loadedFieldNumbers.length > 0) {
String[] loadedFieldNames = new String[loadedFieldNumbers.length];
for (int i = 0; i < loadedFieldNumbers.length; i++) {
loadedFieldNames[i] =
cmd.getMetaDataForManagedMemberAtAbsolutePosition(loadedFieldNumbers[i]).getName();
}
return loadedFieldNames;
}
return null;
}
private static void addColumnsToScanForEmbeddedMember(
Scan scan, List<AbstractMemberMetaData> embMmds, Table table, ExecutionContext ec) {
AbstractMemberMetaData lastMmd = embMmds.get(embMmds.size() - 1);
ClassLoaderResolver clr = ec.getClassLoaderResolver();
AbstractClassMetaData embCmd =
ec.getMetaDataManager().getMetaDataForClass(lastMmd.getTypeName(), clr);
int[] embMmdPosns = embCmd.getAllMemberPositions();
for (int i = 0; i < embMmdPosns.length; i++) {
AbstractMemberMetaData embMmd = embCmd.getMetaDataForManagedMemberAtAbsolutePosition(i);
List<AbstractMemberMetaData> subEmbMmds = new ArrayList<AbstractMemberMetaData>(embMmds);
subEmbMmds.add(embMmd);
RelationType relationType = embMmd.getRelationType(clr);
MemberColumnMapping mapping = table.getMemberColumnMappingForEmbeddedMember(subEmbMmds);
if (RelationType.isRelationSingleValued(relationType)) {
addColumnsToScanForEmbeddedMember(scan, subEmbMmds, table, ec);
} else {
String familyName = HBaseUtils.getFamilyNameForColumn(mapping.getColumn(0));
String qualifName = HBaseUtils.getQualifierNameForColumn(mapping.getColumn(0));
scan.addColumn(familyName.getBytes(), qualifName.getBytes());
}
}
}
/**
* Utility to create the application identity columns and mapping. Uses the id mapping of the
* specified class table and copies the mappings and columns, whilst retaining the passed
* preferences for column namings. This is used to copy the PK mappings of a superclass table so
* we have the same PK.
*
* @param columnContainer The container of column MetaData with any namings
* @param refTable The table that we use as reference
* @param clr The ClassLoaderResolver
* @param cmd The ClassMetaData
*/
final void addApplicationIdUsingClassTableId(
ColumnMetaDataContainer columnContainer,
DatastoreClass refTable,
ClassLoaderResolver clr,
AbstractClassMetaData cmd) {
ColumnMetaData[] userdefinedCols = null;
int nextUserdefinedCol = 0;
if (columnContainer != null) {
userdefinedCols = columnContainer.getColumnMetaData();
}
pkMappings = new JavaTypeMapping[cmd.getPKMemberPositions().length];
for (int i = 0; i < cmd.getPKMemberPositions().length; i++) {
AbstractMemberMetaData mmd =
cmd.getMetaDataForManagedMemberAtAbsolutePosition(cmd.getPKMemberPositions()[i]);
JavaTypeMapping mapping = refTable.getMemberMapping(mmd);
if (mapping == null) {
// probably due to invalid metadata defined by the user
throw new NucleusUserException(
"Cannot find mapping for field "
+ mmd.getFullFieldName()
+ " in table "
+ refTable.toString()
+ " "
+ StringUtils.collectionToString(refTable.getColumns()));
}
JavaTypeMapping masterMapping =
storeMgr.getMappingManager().getMapping(clr.classForName(mapping.getType()));
masterMapping.setMemberMetaData(mmd); // Update field info in mapping
masterMapping.setTable(this);
pkMappings[i] = masterMapping;
// Loop through each id column in the reference table and add the same here
// applying the required names from the columnContainer
for (int j = 0; j < mapping.getNumberOfDatastoreMappings(); j++) {
JavaTypeMapping m = masterMapping;
Column refColumn = mapping.getDatastoreMapping(j).getColumn();
if (mapping instanceof PersistableMapping) {
m =
storeMgr
.getMappingManager()
.getMapping(clr.classForName(refColumn.getJavaTypeMapping().getType()));
((PersistableMapping) masterMapping).addJavaTypeMapping(m);
}
ColumnMetaData userdefinedColumn = null;
if (userdefinedCols != null) {
for (int k = 0; k < userdefinedCols.length; k++) {
if (refColumn.getIdentifier().toString().equals(userdefinedCols[k].getTarget())) {
userdefinedColumn = userdefinedCols[k];
break;
}
}
if (userdefinedColumn == null && nextUserdefinedCol < userdefinedCols.length) {
userdefinedColumn = userdefinedCols[nextUserdefinedCol++];
}
}
// Add this application identity column
Column idColumn = null;
if (userdefinedColumn != null) {
// User has provided a name for this column
// Currently we only use the column namings from the users definition but we could easily
// take more of their details.
idColumn =
addColumn(
refColumn.getStoredJavaType(),
storeMgr
.getIdentifierFactory()
.newIdentifier(IdentifierType.COLUMN, userdefinedColumn.getName()),
m,
refColumn.getColumnMetaData());
} else {
// No name provided so take same as superclass
idColumn =
addColumn(
refColumn.getStoredJavaType(),
refColumn.getIdentifier(),
m,
refColumn.getColumnMetaData());
}
if (mapping.getDatastoreMapping(j).getColumn().getColumnMetaData() != null) {
refColumn.copyConfigurationTo(idColumn);
}
idColumn.setPrimaryKey();
// Set the column type based on the field.getType()
getStoreManager()
.getMappingManager()
.createDatastoreMapping(m, idColumn, refColumn.getJavaTypeMapping().getType());
}
// Update highest field number if this is higher
int absoluteFieldNumber = mmd.getAbsoluteFieldNumber();
if (absoluteFieldNumber > highestMemberNumber) {
highestMemberNumber = absoluteFieldNumber;
}
}
}
