Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* 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 java.lang.reflect.InvocationTargetException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import javax.annotation.Nullable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
import com.google.common.collect.ImmutableList;
import com.mysema.commons.lang.CloseableIterator;
import com.querydsl.core.*;
import com.querydsl.core.support.QueryMixin;
import com.querydsl.core.types.*;
import com.querydsl.core.types.dsl.Expressions;
import com.querydsl.core.types.dsl.SimpleExpression;
import com.querydsl.core.types.dsl.Wildcard;
import com.querydsl.core.util.ResultSetAdapter;
/**
* {@code AbstractSQLQuery} is the base type for SQL query implementations
*
* @param result type
* @param concrete subtype
*
* @author tiwe
*/
public abstract class AbstractSQLQuery> extends ProjectableSQLQuery {
protected static final String PARENT_CONTEXT = AbstractSQLQuery.class.getName() + "#PARENT_CONTEXT";
private static final Logger logger = LoggerFactory.getLogger(AbstractSQLQuery.class);
private static final QueryFlag rowCountFlag = new QueryFlag(QueryFlag.Position.AFTER_PROJECTION, ", count(*) over() ");
@Nullable
private final Connection conn;
protected SQLListeners listeners;
protected boolean useLiterals;
private boolean getLastCell;
private Object lastCell;
private SQLListenerContext parentContext;
public AbstractSQLQuery(@Nullable Connection conn, Configuration configuration) {
this(conn, configuration, new DefaultQueryMetadata());
}
public AbstractSQLQuery(@Nullable Connection conn, Configuration configuration, QueryMetadata metadata) {
super(new QueryMixin(metadata, false), configuration);
this.conn = conn;
this.listeners = new SQLListeners(configuration.getListeners());
this.useLiterals = configuration.getUseLiterals();
}
/**
* Create an alias for the expression
*
* @param alias alias
* @return this as alias
*/
public SimpleExpression as(String alias) {
return Expressions.as(this, alias);
}
/**
* Create an alias for the expression
*
* @param alias alias
* @return this as alias
*/
public SimpleExpression as(Path> alias) {
return Expressions.as(this, (Path) alias);
}
/**
* Add a listener
*
* @param listener listener to add
*/
public void addListener(SQLListener listener) {
listeners.add(listener);
}
@Override
public long fetchCount() {
try {
return unsafeCount();
} catch (SQLException e) {
String error = "Caught " + e.getClass().getName();
logger.error(error, e);
throw configuration.translate(e);
}
}
/**
* If you use forUpdate() with a backend that uses page or row locks, rows examined by the
* query are write-locked until the end of the current transaction.
*
* Not supported for SQLite and CUBRID
*
* @return the current object
*/
public Q forUpdate() {
return addFlag(SQLOps.FOR_UPDATE_FLAG);
}
@Override
protected SQLSerializer createSerializer() {
SQLSerializer serializer = new SQLSerializer(configuration);
serializer.setUseLiterals(useLiterals);
return serializer;
}
@Nullable
private T get(ResultSet rs, Expression> expr, int i, Class type) throws SQLException {
return configuration.get(rs, expr instanceof Path ? (Path>) expr : null, i, type);
}
private void set(PreparedStatement stmt, Path> path, int i, Object value) throws SQLException {
configuration.set(stmt, path, i, value);
}
/**
* Called to create and start a new SQL Listener context
*
* @param connection the database connection
* @param metadata the meta data for that context
* @return the newly started context
*/
protected SQLListenerContextImpl startContext(Connection connection, QueryMetadata metadata) {
SQLListenerContextImpl context = new SQLListenerContextImpl(metadata, connection);
if (parentContext != null) {
context.setData(PARENT_CONTEXT, parentContext);
}
listeners.start(context);
return context;
}
/**
* Called to make the call back to listeners when an exception happens
*
* @param context the current context in play
* @param e the exception
*/
protected void onException(SQLListenerContextImpl context, Exception e) {
context.setException(e);
listeners.exception(context);
}
/**
* Called to end a SQL listener context
*
* @param context the listener context to end
*/
protected void endContext(SQLListenerContext context) {
listeners.end(context);
}
/**
* Get the results as an JDBC result set
*
* @param exprs the expression arguments to retrieve
* @return results as ResultSet
*/
public ResultSet getResults(Expression>... exprs) {
queryMixin.setProjection(exprs);
SQLListenerContextImpl context = startContext(conn, queryMixin.getMetadata());
String queryString = null;
List