org.cloudgraph.hbase.scan.WildcardStringLiteral Maven / Gradle / Ivy

Go to download
/**
 *        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.scan;

import org.cloudgraph.config.UserDefinedRowKeyFieldConfig;
import org.cloudgraph.store.service.GraphServiceException;
import org.plasma.query.Wildcard;
import org.plasma.query.model.WildcardOperator;
import org.plasma.sdo.PlasmaType;


/**
 * A wildcard string data "flavor" specific literal class 
 * used to abstract 
 * the complexities involved in assembling the various 
 * segments and fields of composite (scan start/stop) row keys 
 * under various relational and logical operator and
 * various configurable composite key-field hashing, formatting, padding 
 * and other features.
 * 
 * @see org.cloudgraph.config.TableConfig
 * @see org.cloudgraph.hbase.service.HBaseDataConverter
 * @author Scott Cinnamond
 * @since 0.5
 */
public class WildcardStringLiteral extends StringLiteral 
    implements WildcardPartialRowKeyLiteral, FuzzyRowKeyLiteral {

	@Deprecated
	private WildcardOperator wildcardOperator;

	public WildcardStringLiteral(String literal,
			PlasmaType rootType,
			WildcardOperator wildcardOperator,
			UserDefinedRowKeyFieldConfig fieldConfig) {
		super(literal, rootType, null, 
			  fieldConfig);
		this.wildcardOperator = wildcardOperator;
	}
		

	public WildcardOperator getWildcardOperator() {
		return wildcardOperator;
	}
	
	/**
	 * Returns the HBase scan "start-row" composite row-key field 
	 * bytes for this literal under the various relational, logical 
	 * operator and other optionally configurable hashing, 
	 * formatting and padding features.
	 * @return the HBase scan "start-row" composite row-key field 
	 * bytes for this literal under the various relational, logical 
	 * operator and other optionally configurable hashing, 
	 * formatting and padding features.
	 */
	@Override
	public byte[] getStartBytes() {
		switch (this.wildcardOperator.getValue()) {
		case LIKE:
			return getBetweenStartBytes();
		default:
			throw new GraphServiceException("wildcard operator '"
					+ this.wildcardOperator.getValue().toString() 
					+ "' not supported for string row key fields");
		}
	}
	
	/**
	 * Returns the HBase scan "stop-row" composite row-key field 
	 * bytes for this literal under the various relational, logical 
	 * operator and other optionally configurable hashing, 
	 * formatting and padding features.
	 * @return the HBase scan "stop-row" composite row-key field 
	 * bytes for this literal under the various relational, logical 
	 * operator and other optionally configurable hashing, 
	 * formatting and padding features.
	 */
	@Override
	public byte[] getStopBytes() {
		switch (this.wildcardOperator.getValue()) {
		case LIKE:
			return getBetweenStopBytes();
		default:
			throw new GraphServiceException("wildcard operator '"
					+ this.wildcardOperator.getValue().toString() 
					+ "' not supported for string row key fields");
		}
	}	

	@Override
	public byte[] getFuzzyKeyBytes() {
		byte[] keyBytes = null;
		String keyValueStr = this.literal.trim();		
		if (!fieldConfig.isHash()) {					
			if (keyValueStr.endsWith(Wildcard.WILDCARD_CHAR)) {
				keyValueStr = this.padding.back(keyValueStr, 
						this.fieldConfig.getMaxLength(), 
						Wildcard.WILDCARD_CHAR.charAt(0));
			}
			else if (keyValueStr.startsWith(Wildcard.WILDCARD_CHAR)) {
				keyValueStr = this.padding.front(keyValueStr, 
						this.fieldConfig.getMaxLength(), 
						Wildcard.WILDCARD_CHAR.charAt(0));
			}
			else { // key fields are fixed length - intervening wildcard cannot work
	            throw new ScanException("cannot create fuzzy scan literal "
	                	+ "with interviening wildcards ('"+ keyValueStr +"') for fixed length row key field with path '" 
	            		+ this.fieldConfig.getPropertyPath()
	                	+ "' within table "+this.table.getName()+" for graph root type, "
	                	+ this.rootType.toString());
			}
			keyBytes = keyValueStr.getBytes(this.charset);
		}
		else
            throw new ScanException("cannot create fuzzy scan literal "
            	+ "for hashed key field - field with path '" + this.fieldConfig.getPropertyPath()
            	+ "' within table "+this.table.getName()+" for graph root type, "
            	+ this.rootType.toString() + "is configured as 'hashed'");
		return keyBytes;
	}

	@Override
	public byte[] getFuzzyInfoBytes() {
		byte[] infoBytes = new byte[this.fieldConfig.getMaxLength()];
		byte[] literalChars = getFuzzyKeyBytes();
		char wildcard = Wildcard.WILDCARD_CHAR.toCharArray()[0];
		for (int i = 0; i < infoBytes.length; i++)
			if (literalChars[i] != wildcard)
			    infoBytes[i] = (byte)0; // fixed char
			else
				infoBytes[i] = (byte)1; // fuzzy char
		return infoBytes;
	}


	/**
	 * Returns the "start row" bytes 
	 * used under certain conditions to represent a "wildcard" operator 
	 * under an HBase partial row-key scan under 
	 * the various optionally configurable hashing, 
	 * formatting and padding features. 
	 * @return the "start row" bytes 
	 * used under certain conditions to represent a "wildcard" operator 
	 * under an HBase partial row-key scan under 
	 * the various optionally configurable hashing, 
	 * formatting and padding features.
	 */
	@Override
	public byte[] getBetweenStartBytes() {
		byte[] startBytes = null;
		String startValueStr = this.literal.substring(0, this.literal.length()-1);
		if (!fieldConfig.isHash()) {
			startBytes = startValueStr.getBytes(this.charset);
			startBytes = this.padding.pad(startBytes, 
					this.fieldConfig.getMaxLength(), 
					this.fieldConfig.getDataFlavor());
		}
		else
            throw new ScanException("cannot create scan literal "
            	+ "for hashed key field - field with path '" + this.fieldConfig.getPropertyPath()
            	+ "' within table "+this.table.getName()+" for graph root type, "
            	+ this.rootType.toString() + "is configured as 'hashed'");

		return startBytes;
	}


	/**
	 * Returns the "stop row" bytes 
	 * used under certain conditions to represent a "wildcard" operator 
	 * under an HBase partial row-key scan under 
	 * the various optionally configurable hashing, 
	 * formatting and padding features.
	 * @return the "stop row" bytes 
	 * used under certain conditions to represent a "wildcard" operator 
	 * under an HBase partial row-key scan under 
	 * the various optionally configurable hashing, 
	 * formatting and padding features.
	 */
	@Override
	public byte[] getBetweenStopBytes() {
		byte[] stopBytes = null;
		String stopValueStr = this.literal.substring(0, this.literal.length()-1);
		if (!fieldConfig.isHash()) {			
			byte[] literalStopBytes = stopValueStr.getBytes(this.charset);
			stopBytes = new byte[literalStopBytes.length + 1];
			System.arraycopy(literalStopBytes, 0, stopBytes, 0, literalStopBytes.length);
			stopBytes[stopBytes.length-1] = INCREMENT;
			stopBytes = this.padding.pad(stopBytes, 
					this.fieldConfig.getMaxLength(), 
					this.fieldConfig.getDataFlavor());
		}
		else
            throw new ScanException("cannot create scan literal "
            	+ "for hashed key field - field with path '" + this.fieldConfig.getPropertyPath()
            	+ "' within table "+this.table.getName()+" for graph root type, "
            	+ this.rootType.toString() + "is configured as 'hashed'");
		return stopBytes;
	}
	
}