Only the dirty properties will be set into the result SQL if the specified entity is a dirty marker entity.

@param entity
@param excludedPropNames
@return
165712
public SQLBuilder set(final Object entity, final Set<String> excludedPropNames) {
        if (entity instanceof String) {
            return set(N.asArray((String) entity));
        } else if (entity instanceof Map) {
            if (N.isNullOrEmpty(excludedPropNames)) {
                return set((Map<String, Object>) entity);
            } else {
                final Map<String, Object> props = new LinkedHashMap<>((Map<String, Object>) entity);
                Maps.removeKeys(props, excludedPropNames);
                return set(props);
            }
        } else {
            final Class<?> entityClass = entity.getClass();
            this.entityClass = entityClass;
            final Collection<String> propNames = getUpdatePropNamesByClass(entityClass, excludedPropNames);
            final Set<String> dirtyPropNames = N.isDirtyMarker(entityClass) ? ((DirtyMarker) entity).dirtyPropNames() : null;
            final Map<String, Object> props = N.newHashMap(N.initHashCapacity(N.isNullOrEmpty(dirtyPropNames) ? propNames.size() : dirtyPropNames.size()));

            for (String propName : propNames) {
                if (N.isNullOrEmpty(dirtyPropNames) || dirtyPropNames.contains(propName)) {
                    props.put(propName, ClassUtil.getPropValue(entity, propName));
                }
            }

            return set(props);
        }
    }
977237
private function shouldSkipField(string $propertyName, array $excludedFields): bool
    {
        if ('id' === $propertyName) {
            return true;
        }

        return \in_array($propertyName, $excludedFields, true);
    }
383973
@Override
	public SQLProperty findPropertyByName(String name) {
		name = name.toLowerCase();
		for (SQLProperty item : properties) {
			if (item.getName().toLowerCase().equals(name)) {
				return item;
			}
		}

		return null;
	}
1297882
public void skippedEntity(String name) throws SAXException
  {

    if (DEBUG)
      System.out.println("TransformerHandlerImpl#skippedEntity: " + name);

    if (m_contentHandler != null)
    {
      m_contentHandler.skippedEntity(name);
    }
  }
703702
public void removeEntity(Entity entity){
		boolean delayed = updating || familyManager.notifying();
		entityManager.removeEntity(entity, delayed);
	}
432769
@Override
    public void delete(Object entity, Object pKey)
    {
        EntityMetadata entityMetadata = KunderaMetadataManager.getEntityMetadata(kunderaMetadata, entity.getClass());
        MetamodelImpl metamodel = (MetamodelImpl) KunderaMetadataManager.getMetamodel(kunderaMetadata,
                entityMetadata.getPersistenceUnit());

        String idColumnName = ((AbstractAttribute) entityMetadata.getIdAttribute()).getJPAColumnName();

        Table schemaTable = tableAPI.getTable(entityMetadata.getTableName());

        PrimaryKey key = schemaTable.createPrimaryKey();

        if (metamodel.isEmbeddable(entityMetadata.getIdAttribute().getBindableJavaType()))
        {
            EmbeddableType embeddableId = metamodel.embeddable(entityMetadata.getIdAttribute().getBindableJavaType());
            Set<Attribute> embeddedAttributes = embeddableId.getAttributes();

            for (Attribute embeddedAttrib : embeddedAttributes)
            {
                String columnName = ((AbstractAttribute) embeddedAttrib).getJPAColumnName();
                Object embeddedColumn = PropertyAccessorHelper.getObject(pKey, (Field) embeddedAttrib.getJavaMember());

                NoSqlDBUtils.add(schemaTable.getField(columnName), key, embeddedColumn, columnName);
            }
        }
        else
        {
            NoSqlDBUtils.add(schemaTable.getField(idColumnName), key, pKey, idColumnName);
        }

        tableAPI.delete(key, null, null);
        KunderaCoreUtils.printQuery("Delete data from " + entityMetadata.getTableName() + " for PK " + pKey, showQuery);
    }
1187864
public int removeShapesWithExclusions(String database, Set<GoogleMapShapeType> excludedTypes) {

        int count = 0;

        Map<String, Map<Long, FeatureShape>> tables = getTables(database);

        if (tables != null) {

            Iterator<String> iterator = tables.keySet().iterator();
            while (iterator.hasNext()) {
                String table = iterator.next();

                count += removeShapesWithExclusions(database, table, excludedTypes);

                if (getFeatureIdsCount(database, table) <= 0) {
                    iterator.remove();
                }
            }

        }

        return count;
    }
547338
protected Set<String> getExclusions(AnnotationMetadata metadata,
			AnnotationAttributes attributes) {
		Set<String> excluded = new LinkedHashSet<>();
		excluded.addAll(asList(attributes, "exclude"));
		excluded.addAll(Arrays.asList(attributes.getStringArray("excludeName")));
		excluded.addAll(getExcludeAutoConfigurationsProperty());
		return excluded;
	}
232048
@SuppressWarnings("unchecked")
	@Override
	public <E> SqlEntityDelete<E> delete(final Class<? extends E> entityType) {
		@SuppressWarnings("rawtypes")
		EntityHandler handler = this.getEntityHandler();
		if (!handler.getEntityType().isAssignableFrom(entityType)) {
			throw new IllegalArgumentException("Entity type not supported");
		}

		try {
			TableMetadata metadata = handler.getMetadata(this.transactionManager, entityType);

			SqlContext context = handler.createDeleteContext(this, metadata, entityType, false);
			context.setSqlKind(SqlKind.DELETE);

			return new SqlEntityDeleteImpl<>(this, handler, metadata, context);
		} catch (SQLException e) {
			throw new EntitySqlRuntimeException(SqlKind.DELETE, e);
		}
	}
1086674
public static Map<Short, Object> extractKnownPOITags(Entity entity) {
        Map<Short, Object> tagMap = new HashMap<>();
        OSMTagMapping mapping = OSMTagMapping.getInstance();
        if (entity.getTags() != null) {
            for (Tag tag : entity.getTags()) {
                OSMTag poiTag = mapping.getPoiTag(tag.getKey(), tag.getValue());
                if (poiTag != null) {
                    String wildcard = poiTag.getValue();
                    tagMap.put(poiTag.getId(), getObjectFromWildcardAndValue(wildcard, tag.getValue()));
                }
            }
        }
        return tagMap;
    }
1128925
public void setExcludeProps(Collection<String> excludeProps) {
        if (null == this.excludeProps) {
            this.excludeProps = new ArrayList<>();
        }
        this.excludeProps.clear();
        this.excludeProps.addAll(excludeProps);
    }
1197941
public ClassSelector except(String... propertyNames) {
    if(ArrayUtils.isEmpty(propertyNames)){
      return this;
    }

    boolean updated = false;
    for (String propertyToRemove : propertyNames) {
      if (removePropertySelector(propertyToRemove)) {
        updated = true;
      }
    }

    if (updated) {
      compositeSelector = new CompositeSelector(this.propertySelectors);
    }
    return this;
  }
488105
private boolean isToExclude(NameValuePair param) {
        List<ScannerParamFilter> excludedParameters = getParameterExclusionFilters(param);
        
        // We can use the base one, we don't do anything with it
        HttpMessage msg = getBaseMsg();
        
        for (ScannerParamFilter filter : excludedParameters) {
            if (filter.isToExclude(msg, param)) {
                return true;
            }
        }
        
        return false;
    }
5389
public static void filterMarkerProperty(List<JpaProperty> properties) {
        ListIterator<JpaProperty> propIt = properties.listIterator();
        while (propIt.hasNext()) {
            if (BEAN_MARKER_PROPERTY_NAME.equals(propIt.next().getPropertyName())) {
                propIt.remove();
            }
        }
    }
877842
private SQLQuery query(Class<?>... entity) {
		SQLQuery q = session.createSQLQuery(sql);
		if (entity.length == 1) {
			q.addEntity(entity[0]);
		}
		for (Map.Entry<String, Type> scalar : scalars.entrySet()) {
			q.addScalar(scalar.getKey(), scalar.getValue());
		}
		for (int i = 0; i < positionedParameters.length; i++) {
			q.setParameter(i, positionedParameters[i]);
		}
		for (Map.Entry<String, Object> entry : namedParameters.entrySet()) {
			Object value = entry.getValue();
			if (Types.isArray(value)) {
				Object[] parameter = (Object[]) value;
				if (parameter.length == 0) {
					throw new HibernateException(String.format("Invalid named parameter |%s|. Empty array.", entry.getKey()));
				}
				q.setParameterList(entry.getKey(), parameter);
			} else if (Types.isCollection(value)) {
				Collection<?> parameter = (Collection<?>) value;
				if (parameter.isEmpty()) {
					throw new HibernateException(String.format("Invalid named parameter |%s|. Empty list.", entry.getKey()));
				}
				q.setParameterList(entry.getKey(), parameter);
			} else {
				q.setParameter(entry.getKey(), value);
			}
		}
		if (offset > 0) {
			q.setFirstResult(offset);
		}
		if (rowsCount > 0) {
			q.setMaxResults(rowsCount);
		}
		return q;
	}
155973
public static synchronized List getPropertyNames(String entityTypeName) {
        if (entityTypeName == null) {
            return null;
        }
        if (!entityTypeName.equals("Entity")) {
            return (List) properties.get(entityTypeName);
        }
        if (propertyNames != null) {
            return propertyNames;
        } else {
            {
                List names = new ArrayList();
                names.add(PROP_IDENTIFIER);
                names.add(PROP_VIEW_IDENTIFIERS);
                names.add(PROP_PARENT);
                names.add(PROP_CHILDREN);
                names.add(PROP_GROUPS);
                names.add(PROP_CREATE_TIMESTAMP);
                names.add(PROP_MODIFY_TIMESTAMP);
                names.add(PROP_ENTITLEMENT_INFO);
                names.add(PROP_CHANGE_TYPE);
                propertyNames = Collections.unmodifiableList(names);
                return propertyNames;
            }
        }
    }
999767
public void validateConstraints(Entity entity) {
		for (String propertyName : requiredProperties) {
            Object value = entity.getProperty(propertyName);
			if (value == null || (value instanceof String && ((String) value).length() == 0)) {
				throw new RequiredFieldException("Required property '" + this.persistentClass.getSimpleName() + "." + propertyName + "' is not set");
			}
		}
	}