com.querydsl.sql.RelationalPathBase Maven / Gradle / Ivy
/*
* 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 com.querydsl.core.types.Expression;
import com.querydsl.core.types.FactoryExpression;
import com.querydsl.core.types.Operator;
import com.querydsl.core.types.Ops;
import com.querydsl.core.types.Path;
import com.querydsl.core.types.PathMetadata;
import com.querydsl.core.types.PathMetadataFactory;
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;
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.jetbrains.annotations.Nullable;
/**
* {@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 = new LinkedHashMap<>();
private final List> foreignKeys = new ArrayList<>();
private final List> inverseForeignKeys = new ArrayList<>();
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) {
var foreignKey = new ForeignKey(this, local, foreign);
foreignKeys.add(foreignKey);
return foreignKey;
}
protected ForeignKey createForeignKey(
List> local, List foreign) {
var foreignKey = new ForeignKey(this, new ArrayList<>(local), new ArrayList<>(foreign));
foreignKeys.add(foreignKey);
return foreignKey;
}
protected ForeignKey createInvForeignKey(Path local, String foreign) {
var foreignKey = new ForeignKey(this, local, foreign);
inverseForeignKeys.add(foreignKey);
return foreignKey;
}
protected ForeignKey createInvForeignKey(
List> local, List foreign) {
var foreignKey = new ForeignKey(this, new ArrayList<>(local), new ArrayList<>(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 (var 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() {
return columnMetadata.keySet().toArray(new Path[0]);
}
@Override
protected > P add(P path) {
return path;
}
@Override
public List> getColumns() {
return new ArrayList<>(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);
}
}