openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/kernel/exps/InstanceofExpression.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.    
 */
package org.apache.openjpa.jdbc.kernel.exps;

import java.util.Map;

import org.apache.openjpa.jdbc.meta.ClassMapping;
import org.apache.openjpa.jdbc.meta.Discriminator;
import org.apache.openjpa.jdbc.meta.FieldMapping;
import org.apache.openjpa.jdbc.meta.MappingRepository;
import org.apache.openjpa.jdbc.sql.Joins;
import org.apache.openjpa.jdbc.sql.SQLBuffer;
import org.apache.openjpa.jdbc.sql.Select;
import org.apache.openjpa.kernel.exps.ExpressionVisitor;
import org.apache.openjpa.meta.JavaTypes;

/**
 * Tests whether the given path is an instance of the given class.
 *
 * @author Abe White
 */
class InstanceofExpression
    implements Exp {

    private final PCPath _path;
    private final Class _cls;

    /**
     * Constructor. Supply path and class to test for.
     */
    public InstanceofExpression(PCPath path, Class cls) {
        _path = path;
        _cls = cls;
    }

    public ExpState initialize(Select sel, ExpContext ctx, Map contains) {
        // note that we tell the path to go ahead and join to its related
        // object (if any) in order to access its class indicator
        ExpState pathState = _path.initialize(sel, ctx, Val.JOIN_REL);

        // does this path represent a relation?  if not, what class
        // is the field?
        ClassMapping relMapping = _path.getClassMapping(pathState);
        Class rel = null;
        if (relMapping == null) {
            FieldMapping field = _path.getFieldMapping(pathState);
            switch (field.getTypeCode()) {
                case JavaTypes.MAP:
                    if (_path.isKey())
                        rel = field.getKey().getDeclaredType();
                    // no break
                case JavaTypes.ARRAY:
                case JavaTypes.COLLECTION:
                    rel = field.getElement().getDeclaredType();
                    break;
                default:
                    rel = field.getDeclaredType();
            }
        } else
            rel = relMapping.getDescribedType();

        // if the path represents a relation, get its class indicator and
        // make sure it's joined down to its base type
        Discriminator discrim = (relMapping == null 
            || !relMapping.getDescribedType().isAssignableFrom(_cls)) 
            ? null : relMapping.getDiscriminator();
        ClassMapping mapping = null;
        Joins joins = pathState.joins;
        if (discrim != null) {
            // cache mapping for cast
            MappingRepository repos = ctx.store.getConfiguration().
                getMappingRepositoryInstance();
            mapping = repos.getMapping(_cls, ctx.store.getContext().
                getClassLoader(), false);

            // if not looking for a PC, don't bother with indicator
            if (mapping == null || !discrim.hasClassConditions(mapping, true))
                discrim = null;
            else {
                ClassMapping owner = discrim.getClassMapping();
                ClassMapping from, to;
                if (relMapping.getDescribedType().isAssignableFrom
                    (owner.getDescribedType())) {
                    from = owner;
                    to = relMapping;
                } else {
                    from = relMapping;
                    to = owner;
                }

                for (; from != null && from != to;
                    from = from.getJoinablePCSuperclassMapping())
                    joins = from.joinSuperclass(joins, false);
            }
        }
        return new InstanceofExpState(joins, pathState, mapping, discrim, rel);
    }

    /**
     * Expression state.
     */
    private static class InstanceofExpState
        extends ExpState {

        public final ExpState pathState;
        public final ClassMapping mapping;
        public final Discriminator discrim;
        public final Class rel;

        public InstanceofExpState(Joins joins, ExpState pathState, 
            ClassMapping mapping, Discriminator discrim, Class rel) {
            super(joins);
            this.pathState = pathState;
            this.mapping = mapping;
            this.discrim = discrim;
            this.rel = rel;
        }
    }

    public void appendTo(Select sel, ExpContext ctx, ExpState state, 
        SQLBuffer sql) {
        // if no class indicator or a final class, just append true or false
        // depending on whether the cast matches the expected type
        InstanceofExpState istate = (InstanceofExpState) state;
        if (istate.discrim == null) {
            if (_cls.isAssignableFrom(istate.rel))
                sql.append("1 = 1");
            else
                sql.append("1 <> 1");
        } else {
            ctx.store.loadSubclasses(istate.discrim.getClassMapping());
            SQLBuffer buf = istate.discrim.getClassConditions(sel,
                istate.joins, istate.mapping, true);
            sql.append(buf);
        }
        sel.append(sql, istate.joins);
    }

    public void selectColumns(Select sel, ExpContext ctx, ExpState state, 
        boolean pks) {
        InstanceofExpState istate = (InstanceofExpState) state;
        if (istate.discrim != null)
            sel.select(istate.discrim.getColumns(), istate.joins);
    }

    public void acceptVisit(ExpressionVisitor visitor) {
        visitor.enter(this);
        _path.acceptVisit(visitor);
        visitor.exit(this);
    }
}