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

com.querydsl.sql.RelationalPathBase Maven / Gradle / Ivy

There is a newer version: 5.1.0
Show newest version
/*
 * Copyright 2015, The Querydsl Team (http://www.querydsl.com/team)
 *
 * Licensed 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 com.querydsl.sql;

import static com.google.common.collect.ImmutableList.copyOf;

import java.util.Collection;
import java.util.List;
import java.util.Map;

import javax.annotation.Nullable;

import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.querydsl.core.types.*;
import com.querydsl.core.types.dsl.BeanPath;
import com.querydsl.core.types.dsl.BooleanExpression;
import com.querydsl.core.types.dsl.Expressions;
import com.querydsl.core.types.dsl.NumberExpression;

/**
 * {@code RelationalPathBase} is a base class for {@link RelationalPath} implementations
 *
 * @author tiwe
 *
 * @param 
 *            entity type
 */
public class RelationalPathBase extends BeanPath implements RelationalPath {

    private static final long serialVersionUID = -7031357250283629202L;

    @Nullable
    private PrimaryKey primaryKey;

    private final Map, ColumnMetadata> columnMetadata = Maps.newLinkedHashMap();

    private final List> foreignKeys = Lists.newArrayList();

    private final List> inverseForeignKeys = Lists.newArrayList();

    private final String schema, table;

    private final SchemaAndTable schemaAndTable;

    private transient FactoryExpression projection;

    private transient NumberExpression count, countDistinct;

    public RelationalPathBase(Class type, String variable, String schema, String table) {
        this(type, PathMetadataFactory.forVariable(variable), schema, table);
    }

    public RelationalPathBase(Class type, PathMetadata metadata, String schema,
            String table) {
        super(type, metadata);
        this.schema = schema;
        this.table = table;
        this.schemaAndTable = new SchemaAndTable(schema, table);
    }

    protected PrimaryKey createPrimaryKey(Path... columns) {
        primaryKey = new PrimaryKey(this, columns);
        return primaryKey;
    }

    protected  ForeignKey createForeignKey(Path local, String foreign) {
        ForeignKey foreignKey = new ForeignKey(this, local, foreign);
        foreignKeys.add(foreignKey);
        return foreignKey;
    }

    protected  ForeignKey createForeignKey(List> local, List foreign) {
        ForeignKey foreignKey = new ForeignKey(this, copyOf(local), copyOf(foreign));
        foreignKeys.add(foreignKey);
        return foreignKey;
    }

    protected  ForeignKey createInvForeignKey(Path local, String foreign) {
        ForeignKey foreignKey = new ForeignKey(this, local, foreign);
        inverseForeignKeys.add(foreignKey);
        return foreignKey;
    }

    protected  ForeignKey createInvForeignKey(List> local,
            List foreign) {
        ForeignKey foreignKey = new ForeignKey(this, copyOf(local), copyOf(foreign));
        inverseForeignKeys.add(foreignKey);
        return foreignKey;
    }

    protected 

> P addMetadata(P path, ColumnMetadata metadata) { columnMetadata.put(path, metadata); return path; } @Override public NumberExpression count() { if (count == null) { if (primaryKey != null) { count = Expressions.numberOperation(Long.class, Ops.AggOps.COUNT_AGG, primaryKey.getLocalColumns().get(0)); } else { throw new IllegalStateException("No count expression can be created"); } } return count; } @Override public NumberExpression countDistinct() { if (countDistinct == null) { if (primaryKey != null) { // TODO handle multiple column primary keys properly countDistinct = Expressions.numberOperation(Long.class, Ops.AggOps.COUNT_DISTINCT_AGG, primaryKey.getLocalColumns().get(0)); } else { throw new IllegalStateException("No count distinct expression can be created"); } } return countDistinct; } /** * Compares the two relational paths using primary key columns * * @param right rhs of the comparison * @return this == right */ @Override public BooleanExpression eq(T right) { if (right instanceof RelationalPath) { return primaryKeyOperation(Ops.EQ, primaryKey, ((RelationalPath) right).getPrimaryKey()); } else { return super.eq(right); } } /** * Compares the two relational paths using primary key columns * * @param right rhs of the comparison * @return this == right */ @Override public BooleanExpression eq(Expression right) { if (right instanceof RelationalPath) { return primaryKeyOperation(Ops.EQ, primaryKey, ((RelationalPath) right).getPrimaryKey()); } else { return super.eq(right); } } /** * Compares the two relational paths using primary key columns * * @param right rhs of the comparison * @return this != right */ @Override public BooleanExpression ne(T right) { if (right instanceof RelationalPath) { return primaryKeyOperation(Ops.NE, primaryKey, ((RelationalPath) right).getPrimaryKey()); } else { return super.ne(right); } } /** * Compares the two relational paths using primary key columns * * @param right rhs of the comparison * @return this != right */ @Override public BooleanExpression ne(Expression right) { if (right instanceof RelationalPath) { return primaryKeyOperation(Ops.NE, primaryKey, ((RelationalPath) right).getPrimaryKey()); } else { return super.ne(right); } } private BooleanExpression primaryKeyOperation(Operator op, PrimaryKey pk1, PrimaryKey pk2) { if (pk1 == null || pk2 == null) { throw new UnsupportedOperationException("No primary keys available"); } if (pk1.getLocalColumns().size() != pk2.getLocalColumns().size()) { throw new UnsupportedOperationException("Size mismatch for primary key columns"); } BooleanExpression rv = null; for (int i = 0; i < pk1.getLocalColumns().size(); i++) { BooleanExpression pred = Expressions.booleanOperation(op, pk1.getLocalColumns().get(i), pk2.getLocalColumns().get(i)); rv = rv != null ? rv.and(pred) : pred; } return rv; } @Override public FactoryExpression getProjection() { if (projection == null) { projection = RelationalPathUtils.createProjection(this); } return projection; } public Path[] all() { Path[] all = new Path[columnMetadata.size()]; columnMetadata.keySet().toArray(all); return all; } @Override protected

> P add(P path) { return path; } @Override public List> getColumns() { return Lists.newArrayList(this.columnMetadata.keySet()); } @Override public Collection> getForeignKeys() { return foreignKeys; } @Override public Collection> getInverseForeignKeys() { return inverseForeignKeys; } @Override public PrimaryKey getPrimaryKey() { return primaryKey; } @Override public SchemaAndTable getSchemaAndTable() { return schemaAndTable; } @Override public String getSchemaName() { return schema; } @Override public String getTableName() { return table; } @Override public ColumnMetadata getMetadata(Path column) { return columnMetadata.get(column); } }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy