• Home
• com.landawn
• abacus-entity-manager
• 1.10.3
• source code
• EntityManagerUtil.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.

com.landawn.abacus.core.EntityManagerUtil Maven / Gradle / Ivy

/*
 * Copyright (c) 2015, Haiyang Li.
 * 
 * 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.landawn.abacus.core;

import java.lang.reflect.Field;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

import com.landawn.abacus.DataSet;
import com.landawn.abacus.DirtyMarker;
import com.landawn.abacus.EntityId;
import com.landawn.abacus.annotation.Internal;
import com.landawn.abacus.condition.And;
import com.landawn.abacus.condition.Condition;
import com.landawn.abacus.condition.Equal;
import com.landawn.abacus.condition.IsNull;
import com.landawn.abacus.condition.Or;
import com.landawn.abacus.core.AbacusConfiguration.EntityManagerConfiguration.EntityCacheConfiguration;
import com.landawn.abacus.core.AbacusConfiguration.EntityManagerConfiguration.EntityCacheConfiguration.CustomizedEntityCacheConfiguration;
import com.landawn.abacus.core.AbacusConfiguration.EntityManagerConfiguration.LockConfiguration;
import com.landawn.abacus.core.AbacusConfiguration.EntityManagerConfiguration.QueryCacheConfiguration;
import com.landawn.abacus.core.AbacusConfiguration.EntityManagerConfiguration.QueryCacheConfiguration.CacheResultConditionConfiguration;
import com.landawn.abacus.exception.UncheckedSQLException;
import com.landawn.abacus.idGenerator.IdGenerator;
import com.landawn.abacus.metadata.Association;
import com.landawn.abacus.metadata.Association.JoinType;
import com.landawn.abacus.metadata.EntityDefinition;
import com.landawn.abacus.metadata.EntityDefinitionFactory;
import com.landawn.abacus.metadata.Property;
import com.landawn.abacus.parser.ParserUtil;
import com.landawn.abacus.util.ClassUtil;
import com.landawn.abacus.util.JdbcUtil;
import com.landawn.abacus.util.N;
import com.landawn.abacus.util.ObjectPool;
import com.landawn.abacus.util.Options;
import com.landawn.abacus.util.Options.Cache;
import com.landawn.abacus.util.Options.Jdbc;
import com.landawn.abacus.util.Options.Query;
import com.landawn.abacus.util.WD;
import com.landawn.abacus.util.u.Holder;
import com.landawn.abacus.validator.Validator;

// TODO: Auto-generated Javadoc
/**
 *
 * @author Haiyang Li
 * @since 0.8
 */
@Internal
public final class EntityManagerUtil {

    private static final Map, String> clsEntityName = new ObjectPool<>(1024);

    private EntityManagerUtil() {
        // no instance
    }

    /**
     *
     * @param options
     * @return
     */
    public static Map copyOptions(final Map options) {
        return N.isNullOrEmpty(options) ? ParametersUtil.asOptions() : ParametersUtil.copy(options);
    }

    /**
     * Check if the specified parameter is null or empty.
     *
     * @param 
     * @param parameter
     * @param msg name of parameter or error message
     * @return
     * @throws IllegalArgumentException if the specified parameter is null or empty.
     */
    public static  T checkArgNotNullOrEmpty(final T parameter, final String msg) {
        if (parameter == null || parameter.isEmpty()) {
            if (isNullErrorMsg(msg)) {
                throw new IllegalArgumentException(msg);
            } else {
                throw new IllegalArgumentException("'" + msg + "' can not be null or empty");
            }
        }

        return parameter;
    }

    /**
     * Checks if is null error msg.
     *
     * @param msg
     * @return true, if is null error msg
     */
    private static boolean isNullErrorMsg(final String msg) {
        // shortest message: "it is null"
        return msg.length() > 9 && msg.indexOf(WD._SPACE) > 0;
    }

    /**
     * Check entity name.
     *
     * @param entityDefinitionFactory
     * @param entityName
     * @return
     */
    public static EntityDefinition checkEntityName(final EntityDefinitionFactory entityDefinitionFactory, final String entityName) {
        if (N.isNullOrEmpty(entityName)) {
            throw new IllegalArgumentException("The entity name can not be null or empty");
        }

        EntityDefinition entityDef = entityDefinitionFactory.getDefinition(entityName);

        if (entityDef == null) {
            throw new IllegalArgumentException("No definition found for entity: " + entityName);
        }

        return entityDef;
    }

    /**
     * Check entity id.
     *
     * @param entityDefinitionFactory
     * @param entityId
     * @return
     */
    public static EntityDefinition checkEntityId(final EntityDefinitionFactory entityDefinitionFactory, final EntityId entityId) {
        if ((entityId == null) || entityId.isEmpty()) {
            throw new IllegalArgumentException("EntityId can not be null or empty");
        }

        EntityDefinition entityDef = checkEntityName(entityDefinitionFactory, entityId.entityName());

        for (String propName : entityId.keySet()) {
            if (!entityDef.getProperty(propName).isId()) {
                throw new IllegalArgumentException("Non-definied entity id is found in entityId: " + N.toString(entityId) + ". The defined id properties are: "
                        + entityDef.getIdPropertyNameList());
            }
        }

        return entityDef;
    }

    /**
     * Check entity id.
     *
     * @param entityDefinitionFactory
     * @param entityIds
     * @return
     */
    public static EntityDefinition checkEntityId(final EntityDefinitionFactory entityDefinitionFactory, final List entityIds) {
        if (N.isNullOrEmpty(entityIds)) {
            throw new IllegalArgumentException("EntityIds can not be null or empty");
        }

        final String entityName = entityIds.iterator().next().entityName();
        final EntityDefinition entityDef = checkEntityName(entityDefinitionFactory, entityName);

        for (EntityId entityId : entityIds) {
            if ((entityId == null) || entityId.isEmpty()) {
                throw new IllegalArgumentException("entityId can not be null or empty. entityIds: " + N.toString(entityIds));
            }

            if (!entityId.entityName().equals(entityName)) {
                throw new IllegalArgumentException("Can not input different type entity id. entityIds: " + N.toString(entityIds));
            }

            for (String propName : entityId.keySet()) {
                if (!entityDef.getProperty(propName).isId()) {
                    throw new IllegalArgumentException("Non-definied entity id is found in entityId: " + N.toString(entityId)
                            + ". The defined id properties are: " + entityDef.getIdPropertyNameList());
                }
            }
        }

        return entityDef;
    }

    /**
     *
     * @param entityDefinitionFactory
     * @param entity
     * @return
     */
    public static EntityDefinition checkEntity(final EntityDefinitionFactory entityDefinitionFactory, final Object entity) {
        if (entity == null) {
            throw new IllegalArgumentException("The specified entity can not be null.");
        }

        Class cls = entity.getClass();
        String entityName = clsEntityName.get(cls);

        if (entityName == null) {
            if (entity instanceof MapEntity) {
                entityName = ((MapEntity) entity).entityName();
            } else {
                for (EntityDefinition entityDef : entityDefinitionFactory.getDefinitionList()) {
                    if (entityDef.isSliceEntity()) {
                        continue;
                    }

                    if (cls.equals(entityDef.getTypeClass())) {
                        entityName = entityDef.getName();

                        break;
                    }
                }

                if (entityName == null) {
                    String simpleClassName = ClassUtil.getSimpleClassName(cls);

                    for (EntityDefinition entityDef : entityDefinitionFactory.getDefinitionList()) {
                        if (entityDef.isSliceEntity()) {
                            continue;
                        }

                        if (entityDef.getName().equals(simpleClassName)) {
                            entityName = entityDef.getName();
                        }

                        if (entityName != null) {
                            break;
                        }
                    }
                }

                if (entityName != null) {
                    clsEntityName.put(cls, entityName);
                }
            }
        }

        if (entityName == null) {
            throw new IllegalArgumentException("No entity definition found for class: " + ClassUtil.getCanonicalClassName(cls));
        } else {
            return checkEntityName(entityDefinitionFactory, entityName);
        }
    }

    /**
     *
     * @param entityDefinitionFactory
     * @param entities
     * @return
     */
    public static EntityDefinition checkEntity(final EntityDefinitionFactory entityDefinitionFactory, final Collection entities) {
        if (N.isNullOrEmpty(entities)) {
            throw new IllegalArgumentException("Entities can not be null or empty");
        }

        final Iterator iterator = entities.iterator();
        final Object first = iterator.next();
        final Class cls = first.getClass();

        while (iterator.hasNext()) {
            if (!iterator.next().getClass().equals(cls)) {
                throw new IllegalArgumentException("Can not input different type entity. entities: " + N.toString(entities));
            }
        }

        return checkEntity(entityDefinitionFactory, first);
    }

    /**
     * Check select prop names for get.
     *
     * @param entityDef
     * @param selectPropNames
     */
    public static void checkSelectPropNamesForGet(final EntityDefinition entityDef, final Collection selectPropNames) {
        if (N.notNullOrEmpty(selectPropNames)) {
            Property prop = null;

            for (String propName : selectPropNames) {
                if (propName == null) {
                    throw new IllegalArgumentException("Undefined selection property name(" + propName + ") is specified for the target entity "
                            + entityDef.getName() + ": " + entityDef.getPropertyNameList());
                }

                prop = entityDef.getProperty(propName);

                if ((prop == null) || (prop.getEntityDefinition() != entityDef)) {
                    throw new IllegalArgumentException("Undefined selection property name(" + propName + ") is specified for the target entity "
                            + entityDef.getName() + ": " + entityDef.getPropertyNameList());
                }
            }
        }
    }

    /**
     * Check props list.
     *
     * @param propsList
     */
    public static void checkPropsList(final List> propsList) {
        if (N.isNullOrEmpty(propsList)) {
            throw new IllegalArgumentException("propsList can not be null or empty.");
        }

        int size = propsList.get(0).size();

        for (Map props : propsList) {
            if (props.size() != size) {
                throw new IllegalArgumentException("the size of the properties in the list must be same.");
            }
        }
    }

    /**
     * Check conflict options.
     *
     * @param options
     */
    public static void checkConflictOptions(final Map options) {
        if (isGetFromCache(options) || isCacheResult(options)) {
            if ((options.get(Jdbc.MAX_FIELD_SIZE) != null) || (options.get(Jdbc.MAX_ROWS) != null) || (options.get(Jdbc.FETCH_DIRECTION) != null)) {
                throw new IllegalArgumentException("'FROM_CACHE' or 'CACHE_RESULT' is conflict with 'MAX_ROWS' or 'FETCH_DIRECTION' or 'MAX_FIELD_SIZE'. ");
            }
        }
    }

    /**
     * Gets the prop value by method.
     *
     * @param entity
     * @param prop
     * @return
     */
    public static Object getPropValueByMethod(final Object entity, final Property prop) {
        // return N.invokeMethod(entity, prop.getGetMethod(entity.getClass()));
        return ParserUtil.getEntityInfo(entity.getClass()).getPropValue(entity, prop.getName());
    }

    /**
     * Sets the prop value by method.
     *
     * @param entity
     * @param prop
     * @param propValue
     */
    public static void setPropValueByMethod(final Object entity, final Property prop, Object propValue) {
        if (propValue == null) {
            propValue = N.defaultValueOf(prop.getType().clazz());
        }

        // N.setPropValue(entity, prop.getSetMethod(entity.getClass()), propValue);
        ParserUtil.getEntityInfo(entity.getClass()).setPropValue(entity, prop.getName(), propValue);
    }

    /**
     * Gets the prop value.
     *
     * @param entity
     * @param prop
     * @return
     */
    public static Object getPropValue(final Object entity, final Property prop) {
        if (entity instanceof MapEntity) {
            return ((MapEntity) entity).get(prop.getName());
        } else {
            return getPropValueByMethod(entity, prop);
        }
    }

    /**
     * Sets the prop value.
     *
     * @param entity
     * @param prop
     * @param propValue
     */
    public static void setPropValue(final Object entity, final Property prop, final Object propValue) {
        if (entity instanceof MapEntity) {
            ((MapEntity) entity).set(prop.getName(), propValue);
        } else {
            setPropValueByMethod(entity, prop, propValue);
        }
    }

    /**
     * Gets the signed prop names.
     *
     * @param entityDef
     * @param entity
     * @return
     */
    public static Collection getSignedPropNames(final EntityDefinition entityDef, final Object entity) {
        Collection propNames = null;

        if (DirtyMarkerUtil.isDirtyMarker(entity.getClass())) {
            propNames = DirtyMarkerUtil.signedPropNames((DirtyMarker) entity);
        } else {
            propNames = entityDef.getPropertyNameList();
        }

        return propNames;
    }

    /**
     * Gets the dirty prop names.
     *
     * @param entityDef
     * @param entity
     * @return
     */
    public static Collection getDirtyPropNames(final EntityDefinition entityDef, final Object entity) {
        Collection propNames = null;

        if (DirtyMarkerUtil.isDirtyMarker(entity.getClass())) {
            propNames = DirtyMarkerUtil.dirtyPropNames((DirtyMarker) entity);
        } else {
            propNames = entityDef.getPropertyNameList();
        }

        return propNames;
    }

    /**
     * Gets the updated props.
     *
     * @param entityDef
     * @param entity
     * @return
     */
    public static Map getUpdatedProps(final EntityDefinition entityDef, final Object entity) {
        Collection propNamesToUpdate = getDirtyPropNames(entityDef, entity);
        Map updateProps = new HashMap<>();

        if (entity instanceof MapEntity) {
            MapEntity anEntity = (MapEntity) entity;

            for (String propName : propNamesToUpdate) {
                updateProps.put(propName, anEntity.get(propName));
            }
        } else {
            for (String propName : propNamesToUpdate) {
                Property prop = entityDef.getProperty(propName);
                updateProps.put(propName, getPropValueByMethod(entity, prop));
            }
        }

        for (Property prop : entityDef.getEntiyPropertyList()) {
            if (!updateProps.containsKey(prop.getName())) {
                Object propValue = getPropValue(entity, prop);

                if (propValue != null) {
                    if (prop.isCollection() && propValue instanceof Collection) {
                        @SuppressWarnings("unchecked")
                        Collection