All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.cloudgraph.hbase.key.KeySupport Maven / Gradle / Ivy

Go to download

CloudGraph(tm) is a suite of Service Data Object (SDO) 2.1 services designed for relational and big-table style "cloud" databases, such as HBase and others.

There is a newer version: 2.0.4
Show newest version
/**
 *        CloudGraph Community Edition (CE) License
 * 
 * This is a community release of CloudGraph, a dual-license suite of
 * Service Data Object (SDO) 2.1 services designed for relational and 
 * big-table style "cloud" databases, such as HBase and others. 
 * This particular copy of the software is released under the 
 * version 2 of the GNU General Public License. CloudGraph was developed by 
 * TerraMeta Software, Inc.
 * 
 * Copyright (c) 2013, TerraMeta Software, Inc. All rights reserved.
 * 
 * General License information can be found below.
 * 
 * This distribution may include materials developed by third
 * parties. For license and attribution notices for these
 * materials, please refer to the documentation that accompanies
 * this distribution (see the "Licenses for Third-Party Components"
 * appendix) or view the online documentation at 
 * . 
 */
package org.cloudgraph.hbase.key;

import java.util.List;

import javax.xml.namespace.QName;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.hadoop.hbase.util.Hash;
import org.cloudgraph.common.CloudGraphConstants;
import org.cloudgraph.config.CloudGraphConfigurationException;
import org.cloudgraph.config.PreDefinedKeyFieldConfig;
import org.cloudgraph.config.PredefinedField;
import org.cloudgraph.config.TableConfig;
import org.cloudgraph.config.UserDefinedRowKeyFieldConfig;
import org.cloudgraph.hbase.scan.StringLiteral;
import org.cloudgraph.hbase.service.CloudGraphContext;
import org.cloudgraph.store.key.KeyValue;
import org.plasma.sdo.PlasmaDataObject;
import org.plasma.sdo.PlasmaType;

import commonj.sdo.DataGraph;
import commonj.sdo.DataObject;

/**
 * Delegate class supporting composite key generation.
 * @author Scott Cinnamond
 * @since 0.5
 */
public class KeySupport {
	private static final Log log = LogFactory.getLog(CompositeRowKeyFactory.class);

	/**
	 * Returns the specific configured hash algorithm 
	 * configured for an HTable, or if not configured
	 * returns the configured HBase hash algorithm as
	 * configured within HBase using the 'hbase.hash.type'
	 * property.
	 * @return the specific configured hash algorithm 
	 * configured for an HTable.
	 */
	public Hash getHashAlgorithm(TableConfig table) {
		Hash hash = null; 
		if (table.hasHashAlgorithm()) {
			String hashName = table.getTable().getHashAlgorithm().getName().value();
		    hash = Hash.getInstance(Hash.parseHashType(hashName));
		}
		else {
		    String algorithm = CloudGraphContext.instance().getConfig().get(
		    		CloudGraphConstants.PROPERTY_CONFIG_HASH_TYPE);
		    if (algorithm != null)
		        hash = Hash.getInstance(Hash.parseHashType(algorithm));			
		}
		return hash;
	}

    public KeyValue findKeyValue(UserDefinedRowKeyFieldConfig fieldConfig, List pairs) {
    	
    	commonj.sdo.Property fieldProperty = fieldConfig.getEndpointProperty();
    	commonj.sdo.Type fieldPropertyType = fieldProperty.getContainingType();
    	
		for (KeyValue keyValue : pairs) {
			if (keyValue.getProp().getName().equals(fieldConfig.getEndpointProperty().getName())) {
				if (keyValue.getProp().getContainingType().getName().equals(fieldPropertyType.getName())) {
					if (keyValue.getProp().getContainingType().getURI().equals(fieldPropertyType.getURI())) {
					    if (fieldConfig.getPropertyPath() != null) {
					    	if (keyValue.getPropertyPath() != null && 
					    		keyValue.getPropertyPath().equals(fieldConfig.getPropertyPath())) {
					    		return keyValue;
					    	}
					    }
					}					
				}
			}
		}
		return null;
    }    

	/**
	 * Returns a token value from the given Type
	 * @param type the SDO Type 
	 * @param hash the hash algorithm to use in the event the
	 * row key token is to be hashed 
	 * @param token the pre-defined row key token configuration
	 * @return the token value
	 */
    public String getPredefinedFieldValue(
			PlasmaType type, Hashing hashing, 
			PreDefinedKeyFieldConfig token) {
		String result = null;
		switch (token.getName()) {
		case URI: 
			result = type.getURIPhysicalName();
			if (result == null || result.length() == 0) {
				if (log.isDebugEnabled())
				    log.debug("no URI physical name for type, "
				    		+ type 
				    		+ ", defined - using logical name");
				result = type.getURI();
			}
			break;
		case TYPE:
			result = type.getPhysicalName();
			if (result == null || result.length() == 0) {
				if (log.isDebugEnabled())
				    log.debug("no physical name for type, "
				    		+ type 
				    		+ ", defined - using logical name");
				result = type.getName();
			}
			break;
		default:
		    throw new CloudGraphConfigurationException("invalid row key token name, "
		    		+ token.getName().name() + " - cannot get this token from a SDO Type");
		}
		
		if (token.isHash()) {
			result = hashing.toString(result);
		}
		
		return result;
	}
    
    public byte[] getPredefinedFieldValueStartBytes(
			PlasmaType type, Hashing hashing, 
			PreDefinedKeyFieldConfig token) {
    	return getPredefinedFieldValueBytes(type, hashing, token);
    }
    
    public byte[] getPredefinedFieldValueStopBytes(
			PlasmaType type, Hashing hashing, 
			PreDefinedKeyFieldConfig token) {
		byte[] result = null;
		switch (token.getName()) {
		case URI: 
			if (token.isHash()) {
				byte[] uriBytes = type.getURIPhysicalNameBytes();
				if (uriBytes == null || uriBytes.length == 0) {
					if (log.isDebugEnabled())
					    log.debug("no URI physical name for type, " + type 
					    		+ ", defined - using logical name");
					uriBytes = type.getURIBytes();
				}
				result = hashing.toStringBytes(uriBytes, 1);
			}
			else {
				String uriName = type.getURIPhysicalName();
				if (uriName == null || uriName.length() == 0) {
					if (log.isDebugEnabled())
					    log.debug("no URI physical name for type, " + type 
					    		+ ", defined - using logical name");
					uriName = type.getURI();
				}
				uriName += StringLiteral.INCREMENT;
				result = Bytes.toBytes(uriName);
			}
			break;
		case TYPE:
			if (token.isHash()) {
				byte[] nameBytes = type.getPhysicalNameBytes();
				if (nameBytes == null || nameBytes.length == 0) {
					if (log.isDebugEnabled())
					    log.debug("no physical name for type, " + type 
					    		+ ", defined - using logical name");
					nameBytes = type.getNameBytes();
				}
				result = hashing.toStringBytes(nameBytes, 1);
			}
			else {
				String nameString = type.getPhysicalName();
				if (nameString == null) {
					if (log.isDebugEnabled())
					    log.debug("no physical name for type, " + type 
					    		+ ", defined - using logical name");
					nameString = type.getName();
				}
				nameString += StringLiteral.INCREMENT;
				result = Bytes.toBytes(nameString);
			}
			break;
		default:
		    throw new CloudGraphConfigurationException("invalid row key token name, "
		    		+ token.getName().name() + " - cannot get this token from a SDO Type");
		}
		
		return result;
    }

    public byte[] getPredefinedFieldValueBytes(
			PlasmaType type, Hashing hashing, 
			PreDefinedKeyFieldConfig token) {
		byte[] result = null;
		switch (token.getName()) {
		case URI: 
			result = type.getURIPhysicalNameBytes();
			if (result == null || result.length == 0) {
				if (log.isDebugEnabled())
				    log.debug("no URI physical name for type, " + type 
				    		+ ", defined - using logical name");
				result = type.getURIBytes();
			}
			break;
		case TYPE:
			result = type.getPhysicalNameBytes();
			if (result == null || result.length == 0) {
				if (log.isDebugEnabled())
				    log.debug("no physical name for type, " + type 
				    		+ ", defined - using logical name");
				result = type.getNameBytes();
			}
			break;
		default:
		    throw new CloudGraphConfigurationException("invalid row key token name, "
		    		+ token.getName().name() + " - cannot get this token from a SDO Type");
		}
		
		if (token.isHash()) {
			result = hashing.toStringBytes(result);
		}
		
		return result;
	}
	
	/**
	 * Returns a token value from the given Data Graph
	 * @param dataGraph the data graph 
	 * @param hash the hash algorithm to use in the event the
	 * row key token is to be hashed 
	 * @param token the pre-defined row key token configuration
	 * @return the token value
	 */
	public byte[] getPredefinedFieldValueBytes(
			DataGraph dataGraph, Hash hash, 
			PredefinedField token) {
		return getPredefinedFieldValueBytes(dataGraph.getRootObject(),
			hash, token);
	}
    
    /**
	 * Returns a token value from the given data object
	 * @param dataObject the root data object 
	 * @param hash the hash algorithm to use in the event the
	 * row key token is to be hashed 
	 * @param token the pre-defined row key token configuration
	 * @return the token value
	 */
	public byte[] getPredefinedFieldValueBytes(
			DataObject dataObject, Hash hash, 
			PredefinedField token) {
		PlasmaType rootType = (PlasmaType)dataObject.getType();
		
		byte[] result = null;
		switch (token.getName()) {
		case URI: 
			result = rootType.getURIBytes();
			break;
		case TYPE:
			QName qname = rootType.getQualifiedName();
			
			result = rootType.getPhysicalNameBytes();
			if (result == null || result.length == 0) {
				if (log.isDebugEnabled())
				    log.debug("no physical name for type, "
				    		+ qname.getNamespaceURI() + "#" + rootType.getName() 
				    		+ ", defined - using logical name");
				result = rootType.getNameBytes();
			}
			break;
		case UUID:
			result = Bytes.toBytes(((PlasmaDataObject)dataObject).getUUIDAsString());
			break;
		default:
		    throw new CloudGraphConfigurationException("invalid row key token name, "
		    		+ token.getName().name() + " - cannot get this token from a Data Graph");
		}
		
		if (token.isHash()) {
			int hashValue = hash.hash(result);
			result = Bytes.toBytes(String.valueOf(hashValue));
		}
		
		return result;
	}
}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy