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

com.bigdata.rdf.internal.constraints.RangeBOp Maven / Gradle / Ivy

Go to download

Blazegraph(TM) DB Core Platform. It contains all Blazegraph DB dependencies other than Blueprints.

There is a newer version: 2.1.4
Show newest version
/**

Copyright (C) SYSTAP, LLC DBA Blazegraph 2006-2016.  All rights reserved.

Contact:
     SYSTAP, LLC DBA Blazegraph
     2501 Calvert ST NW #106
     Washington, DC 20008
     licenses@blazegraph.com

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
package com.bigdata.rdf.internal.constraints;

import java.util.LinkedHashMap;
import java.util.Map;

import com.bigdata.bop.BOp;
import com.bigdata.bop.Constant;
import com.bigdata.bop.IBindingSet;
import com.bigdata.bop.IConstant;
import com.bigdata.bop.IValueExpression;
import com.bigdata.bop.ImmutableBOp;
import com.bigdata.bop.ModifiableBOpBase;
import com.bigdata.bop.NV;
import com.bigdata.rdf.error.SparqlTypeErrorException;
import com.bigdata.rdf.internal.IV;

/**
 * Operator used to impose a key-range constraint on a variable on access path.
 * 
 * @see https://sourceforge.net/apps/trac/bigdata/ticket/238 (Lift range
 *      constraints onto AP).
 *      
 * @author mrpersonick
 */
@SuppressWarnings("rawtypes")
final public class RangeBOp extends ModifiableBOpBase { // implements IVariable {

    /**
	 * 
	 */
    private static final long serialVersionUID = 3368581489737593349L;

//	private static final Logger log = Logger.getLogger(RangeBOp.class);
	
    public interface Annotations extends ImmutableBOp.Annotations {

//        /**
//         * The variable whose range is restricted by the associated
//         * {@link #FROM} and/or {@link #TO} filters.
//         */
//		String VAR = RangeBOp.class.getName() + ".var";

		/** The inclusive lower bound. */
		String FROM = RangeBOp.class.getName() + ".from";
		
		/** The exclusive upper bound. */
		String TO = RangeBOp.class.getName() + ".to";
		
    }
    
//    /** Cached to/from lookups. */
//    private transient volatile IValueExpression to, from;

    public RangeBOp() {
    	
        this(BOp.NOARGS, new LinkedHashMap());
        
    }
    
//    public RangeBOp(final IVariable var) {
//    	
//        this(BOp.NOARGS, NV.asMap(new NV(Annotations.VAR, var)));
//        
//    }
    
    public RangeBOp(//final IVariable var,
    		final IValueExpression from, 
    		final IValueExpression to) {

        this(BOp.NOARGS, NV.asMap(
//    			new NV(Annotations.VAR, var),
			    new NV(Annotations.FROM, from),
				new NV(Annotations.TO, to)));

    }

	/**
	 * Required shallow copy constructor.
	 */
    public RangeBOp(final BOp[] args, final Map anns) {
        super(args,anns);
    }

    /**
     * Constructor required for {@link com.bigdata.bop.BOpUtility#deepCopy(FilterNode)}.
     */
    public RangeBOp(final RangeBOp op) {
        super(op);
    }

//    @SuppressWarnings("unchecked")
//    public IVariable var() {
//    	return (IVariable) getProperty(Annotations.VAR);
//    }
    
    @SuppressWarnings("unchecked")
	public IValueExpression from() {
		return (IValueExpression) getProperty(Annotations.FROM);
	}
    
    @SuppressWarnings("unchecked")
	public IValueExpression to() {
		return (IValueExpression) getProperty(Annotations.TO);
    }
    
    public void setFrom(final IValueExpression from) {
    	setProperty(Annotations.FROM, from);
    }

    public void setTo(final IValueExpression to) {
    	setProperty(Annotations.TO, to);
    }

//    final public Range get(final IBindingSet bs) {
//        
////    	log.debug("getting the asBound value");
//    	
//    	final IV from = from().get(bs);
//    	
////    	log.debug("from: " + from);
//    	
//    	// sort of like Var.get(), which returns null when the variable
//    	// is not yet bound
//		if (from == null)
//			return null;
//    	
//    	final IV to = to().get(bs);
//    	
////    	log.debug("to: " + to);
//    	
//    	// sort of like Var.get(), which returns null when the variable
//    	// is not yet bound
//		if (to == null)
//			return null;
//
//    	try {
//    	    /*
//    	     * FIXME Should handle from/to (non-)exclusive boundaries using a
//    	     * successor pattern.
//    	     */
//    		// let Range ctor() do the type checks and valid range checks
//    		return new Range(from, to);
//    	} catch (IllegalArgumentException ex) {
//    		// log the reason the range is invalid
////    		if (log.isInfoEnabled())
////    			log.info("dropping solution: " + ex.getMessage());
//    		// drop the solution
//    		throw new SparqlTypeErrorException();
//    	}
//    	
//    }
//    
    final public RangeBOp asBound(final IBindingSet bs) {

    	/*
    	 * Only care if we change from a non-null, non-Constant to a ground IV.
    	 */
    	final IValueExpression origFrom = from();
    	final IValueExpression origTo = to();
    	
		IValueExpression asBoundFrom;
		{
			if (origFrom == null) {
				asBoundFrom = null;
			} else if (origFrom instanceof IConstant) {
				asBoundFrom = origFrom;
			} else {
				try {
					final IV iv = origFrom.get(bs);
					asBoundFrom = new Constant(iv);
				} catch (SparqlTypeErrorException ex) {
					asBoundFrom = origFrom;
				}
			}
		}
		
		IValueExpression asBoundTo;
		{
			if (origTo == null) {
				asBoundTo = null;
			} else if (origTo instanceof IConstant) {
				asBoundTo = origTo;
			} else {
				try {
					final IV iv = origTo.get(bs);
					asBoundTo = new Constant(iv);
				} catch (SparqlTypeErrorException ex) {
					asBoundTo = origTo;
				}
			}
		}
		
		/*
		 * Null means no value expression, constant value expression, or not
		 * able to evaluate at this time.  Non-null means the asBound is 
		 * different from the original.
		 */
		if (asBoundFrom == origFrom && asBoundTo == origTo) {
			return this;
		}
		
		final RangeBOp asBound = new RangeBOp();
		if (asBoundFrom != null)
			asBound.setFrom(asBoundFrom);
		if (asBoundTo != null)
			asBound.setTo(asBoundTo);
		
		return asBound;
		
	}
    
//    final public boolean isFullyBound() {
//    	
//    	return (from() == null || from() instanceof IConstant) && 
//    		   (to() == null || to() instanceof IConstant);
//    	
//    }
    
    final public boolean isFromBound() {
    	return from() instanceof IConstant;
    }
    
    final public boolean isToBound() {
    	return to() instanceof IConstant;
    }
    
//
////	@Override
//	public boolean isVar() {
//		return true;
//	}
//
////	@Override
//	public boolean isConstant() {
//		return false;
//	}
//
////	@Override
//	public Range get() {
////		log.debug("somebody tried to get me");
//		
//		return null;
//	}
//
////	@Override
//	public String getName() {
//		return var().getName();
//	}
//
////	@Override
//	public boolean isWildcard() {
//		return false;
//	}
//
//
//	/*
//	 * TODO The default BOp equals() and hashCode() should be fine.
//	 */
//	
//	// TODO This looks dangerous. It is only considering the variable!
//    final public boolean equals(final IVariableOrConstant op) {
//
//    	if (op == null)
//    		return false;
//    	
//    	if (this == op) 
//    		return true;
//
//        if (op instanceof IVariable) {
//
//            return var().getName().equals(((IVariable) op).getName());
//
//        }
//        
//        return false;
//    	
//    }
//    
////    final private boolean _equals(final RangeBOp op) {
////    	
////    	return var().equals(op.var())
////    		&& from().equals(op.from())
////    		&& to().equals(op.to());
////
////    }
//    
//	/**
//	 * Caches the hash code.
//	 */
////	private int hash = 0;
//	public int hashCode() {
////		
////		int h = hash;
////		if (h == 0) {
////			h = 31 * h + var().hashCode();
////			h = 31 * h + from().hashCode();
////			h = 31 * h + to().hashCode();
////			hash = h;
////		}
////		return h;
////
//		return var().hashCode();
//	}

}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy