• Home
• com.github.buckelieg
• jdbc-fn
• 1.0
• source code
• Select.java

×

Project download

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.

buckelieg.jdbc.Select Maven / Gradle / Ivy

/*
 * Copyright 2016- Anatoly Kutyakov
 *
 * 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 buckelieg.jdbc;

import buckelieg.jdbc.fn.*;

import javax.annotation.Nonnull;
import javax.annotation.ParametersAreNonnullByDefault;
import javax.annotation.concurrent.NotThreadSafe;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Optional;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import static java.util.Optional.ofNullable;

/**
 * An abstraction for SELECT statement
 */
@SuppressWarnings("unchecked")
@NotThreadSafe
@ParametersAreNonnullByDefault
public interface Select extends Query {

  /**
   * The N+1 problem resolution.
   * 
Represents a {@code Select} statement which results will be processed in batch mode
   *
   * @param  a type of processed entity
   */
  interface ForBatch {

	/**
	 * Sets a size of a batch that will be used to generates chunks with
	 * 
Negative value of this parameter is silently ignored
	 *
	 * @param batchSize a size of a batch (must be positive number). Default value is {@code 1}
	 * @return select for batch processing query abstraction
	 */
	@Nonnull
	ForBatch size(int batchSize);

	/**
	 * Executes this SELECT statement applying a {@code batchProcessor} function to each chunk

	 * 

	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
A {@code batchProcessor} function parameters
Argument
Type
Description
batch
{@linkplain List}
a list of items sliced by the {@linkplain #size(int)} value
	 *
	 * @param batchProcessor a batch processor function
	 * @return a {@linkplain Stream} of resulting (post-processed) items
	 */
	@Nonnull
	default Stream execute(TryConsumer, ? extends Exception> batchProcessor) {
	  if (null == batchProcessor) throw new NullPointerException("Batch processor function must be provided");
	  return execute((batch, session) -> batchProcessor.accept(batch));
	}

	/**
	 * Executes this SELECT statement applying a {@code batchProcessor} function to each chunk

	 * 

	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
A {@code batchProcessor} function parameters
Argument
Type
Description
batch
{@linkplain List}
a list of items sliced by the {@linkplain #size(int)} value
session
{@linkplain Session}
a query session bound to this implicitly created transaction
	 *
	 * @param batchProcessor a batch processor function
	 * @return a {@linkplain Stream} of resulting (post-processed) items
	 */
	@Nonnull
	default Stream execute(TryBiConsumer, Session, ? extends Exception> batchProcessor) {
	  if (null == batchProcessor) throw new NullPointerException("Batch processor function must be provided");
	  return execute((batch, session, batchIndex) -> batchProcessor.accept(batch, session));
	}

	/**
	 * Executes this SELECT statement applying a {@code batchProcessor} function to each chunk

	 * 

	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
A {@code batchProcessor} function parameters
Argument
Type
Description
batch
{@linkplain List}
a list of items sliced by the {@linkplain #size(int)} value
session
{@linkplain Session}
a query session bound to this implicitly created transaction
index
{@linkplain Integer}
current batch number being processed
	 *
	 * @param batchProcessor a batch processor function
	 * @return a {@linkplain Stream} of resulting (post-processed) items
	 */
	@Nonnull
	Stream execute(TryTriConsumer, Session, Integer, ? extends Exception> batchProcessor);

  }

  /**
   * Executes this SELECT statement applying a {@code batchProcessor} function to each chunk

   * 

   * 
   * 
   * 
   * 
   * 
   * 
   * 
   * 
   * 
   * 
   * 
   * 
   * 
   * 
   * 
   * 
   * 
a {@code mapper} function parameters
Argument
Type
Description
rs
{@linkplain ValueReader}
a convenient wrapper for {@linkplain ResultSet} for value read
index
{@linkplain Integer}
current underlying {@linkplain ResultSet} number being processed
   *
   * @param mapper a {@link ResultSet} mapper function which is not required to handle {@link SQLException}
   * @param     an element type
   * @return select for batch processing query abstraction
   */
  @Nonnull
   ForBatch forBatch(TryBiFunction mapper);

  /**
   * @param mapper a {@link ResultSet} mapper function which is not required to handle {@link SQLException}
   * @param     an element type
   * @return select for batch processing query abstraction
   */
  @Nonnull
  default  ForBatch forBatch(TryFunction mapper) {
	if (null == mapper) throw new NullPointerException("Mapper must be provided");
	return forBatch((rs, i) -> mapper.apply(rs));
  }

  /**
   * @return select for batch processing query abstraction
   */
  @Nonnull
  default ForBatch> forBatch() {
	return forBatch(JDBCDefaults::defaultMapper);
  }

  /**
   * Retrieves a metadata for this SELECT statement

   * 

   * 
   * 
   * 
   * 
   * 
   * 
   * 
   * 
   * 
   * 
   * 
   * 
a {@code mapper} function parameters
Argument
Type
Description
meta
{@linkplain Metadata}
a convenient wrapper for {@linkplain ResultSet} metadata read
   *
   * @param mapper {@linkplain Metadata} mapper
   * @return a {@linkplain Metadata} for this query
   * @throws NullPointerException if {@code mapper} is null
   */
  @Nonnull
   T forMeta(Function mapper);

  /**
   * In cases when single result of SELECT statement is expected
   * 
Like SELECT COUNT(*) FROM TABLE_NAME etc

   * 

   * 
   * 
   * 
   * 
   * 
   * 
   * 
   * 
   * 
   * 
   * 
   * 
a {@code mapper} function parameters
Argument
Type
Description
rs
{@linkplain ValueReader}
a convenient wrapper for {@linkplain ResultSet} for value read
   *
   * @param mapper a {@link ResultSet} mapper function which is not required to handle {@link SQLException}
   * @throws NullPointerException if mapper is null
   * @see #execute(TryFunction)
   */
  @Nonnull
  default  Optional single(TryFunction mapper) {
	T result;
	try {
	  result = fetchSize(1).maxRows(1).execute(mapper).collect(Collectors.toList()).iterator().next();
	} catch (NoSuchElementException e) {
	  result = null;
	} catch (Exception e) {
	  throw SQLRuntimeException.class.isAssignableFrom(e.getClass()) ? Utils.newSQLRuntimeException(e) : new RuntimeException(e);
	}
	return ofNullable(result);
  }


  /**
   * Executes SELECT statement for SINGLE result with default mapper applied
   *
   * @return an {@link Optional} with the {@link Map} as a value
   */
  @Nonnull
  default Optional> single() {
	return single(JDBCDefaults::defaultMapper);
  }

  /**
   * Executes this SELECT statement returning a {@code Stream} of mapped values as {@code Map}s
   *
   * @return a {@link Stream} of {@link Map}s
   * @see #execute(TryFunction)
   */
  @Nonnull
  default Stream> execute() {
	return execute(JDBCDefaults::defaultMapper);
  }

  /**
   * 
   *     
   *     
   *         
   *         
   *         
   *     
   *     
   *         
   *         
   *         
   *     
   *     
   *         
   *         
   *         
   *     
   * 
a {@code mapper} function parameters
Argument
Type
Description
rs
{@linkplain ValueReader}
a convenient wrapper for {@linkplain ResultSet} for value read
index
{@linkplain Integer}
current underlying {@linkplain ResultSet} number being processed
   *
   * @param mapper a {@link ResultSet} mapper function which is not required to handle {@link SQLException}
   * @param     item type
   * @return a {@link Stream} over mapped {@link ResultSet}
   * @throws NullPointerException if mapper is null
   */
  @Nonnull
   Stream execute(TryBiFunction mapper);

  /**
   * Executes this SELECT statement returning a {@code Stream} of mapped values over {@code ResultSet} object

   * 

   * 
   * 
   * 
   * 
   * 
   * 
   * 
   * 
   * 
   * 
   * 
   * 
a {@code mapper} function parameters
Argument
Type
Description
rs
{@linkplain ValueReader}
a convenient wrapper for {@linkplain ResultSet} for value read
   *
   * @param mapper a {@link ResultSet} mapper function which is not required to handle {@link SQLException}
   * @return a {@link Stream} over mapped {@link ResultSet}
   * @throws NullPointerException if mapper is null
   * @throws SQLRuntimeException  as a wrapper for {@link SQLException}
   * @throws NullPointerException if mapper is null
   * @see #execute()
   * @see ValueReader
   */
  @Nonnull
  default  Stream execute(TryFunction mapper) {
	if (null == mapper) throw new NullPointerException("Mapper must be provided");
	return execute((rs, i) -> mapper.apply(rs));
  }

  /**
   * Configures {@link java.sql.Statement} fetch size parameter

   * Default value is 15
   *
   * @param size desired fetch size. Should be greater than 0
   * @return select query abstraction
   * @implNote Default value is 15
   * @see java.sql.Statement#setFetchSize(int)
   * @see ResultSet#setFetchSize(int)
   */
  @Nonnull
  Select fetchSize(int size);

  /**
   * Updates max rows obtained with this query
   *
   * @param max rows number limit
   * @return select query abstraction
   * @see java.sql.Statement#setMaxRows(int)
   */
  @Nonnull
  Select maxRows(int max);

  /**
   * Updates max rows obtained with this query
   *
   * @param max rows number limit
   * @return select query abstraction
   * @see java.sql.Statement#setLargeMaxRows(long)
   */
  @Nonnull
  Select maxRows(long max);
}
    

    

    

            
    

            

    
    






    
© 2015 - 2024 Weber Informatics LLC | Privacy Policy