org.jooq.RecordMapper Maven / Gradle / Ivy
/*
* 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
*
* https://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.
*
* Other licenses:
* -----------------------------------------------------------------------------
* Commercial licenses for this work are available. These replace the above
* ASL 2.0 and offer limited warranties, support, maintenance, and commercial
* database integrations.
*
* For more information, please visit: https://www.jooq.org/legal/licensing
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
package org.jooq;
import java.util.function.Function;
import org.jetbrains.annotations.Nullable;
/**
* A RecordMapper is a mapper that can receive {@link Record}
* objects, when fetching data from the database, transforming them into a
* custom type <E>.
*
* RecordMapper is used behind the scenes in methods like
* {@link ResultQuery#fetchInto(Class)}, {@link Result#into(Class)},
* {@link Record#into(Class)} and other methods called into(Class),
* where the argument class is a Class of type E.
*
* The default RecordMapper behaviour in the context of a
* {@link Configuration} can be overridden through that
* configuration's {@link Configuration#recordMapperProvider()}
* SPI. Custom record mappers can be constructed using lambda expressions, using
* various {@link Records#mapping(Function1)},
* {@link Records#mapping(Function2)}, etc. utilities, and other ways.
*
* A {@link RecordMapper} is never asked to map null record values,
* which can be obtained using methods like
* {@link ResultQuery#fetchOne(RecordMapper)}, or by using {@link RowN} types as
* nested records in scalar subqueries, mapping them e.g. via
* {@link Row2#mapping(Function2)}. Instead, null is produced
* without passing by this SPI.
*
* The inverse operation is modelled by {@link RecordUnmapper}.
*
* @author Lukas Eder
*/
@FunctionalInterface
public interface RecordMapper extends Function {
/**
* Map a record into a POJO.
*
* @param record The record to be mapped. This is never null.
* @return The mapped value, which may be null in some
* implementations.
*/
@Nullable
E map(R record);
@Override
default E apply(R record) {
return map(record);
}
}