This property has no other meaning than knowing that a bean
exits only by looking at the properties table.

So remove the marker property from result of a fetch operation.
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();
            }
        }
    }
484823
private boolean internalRemove(Object o, boolean publicApi) {

        if (!contains(o)) return false;

        // todo: for multithreaded usage this block needs to be synchronized
        BeanContextChild bcc = null;
        if (o instanceof BeanContextProxy) {
            bcc = ((BeanContextProxy) o).getBeanContextProxy();
        }
        else if (o instanceof BeanContextChild) {
            bcc = (BeanContextChild) o;
        }

        if (bcc != null) {

            /*
             If remove invoked as a result of the BeanContext receiving an unexpected PropertyChangeEvent
             notification as a result of a 3rd party invoking setBeanContext() then the remove implementation
             shall not invoke setBeanContext(null) on that child as part of the remove() semantics, since
             doing so would overwrite the value previously set by the 3rd party.
            */
            if (publicApi) {

                // remove the property/veto listeners -- we know we want to remove the bean
                // and don't need to be notified if we have initiated the removal
                bcc.removePropertyChangeListener("beanContext", _childPcl);
                bcc.removeVetoableChangeListener("beanContext", _childVcl);

                try {
                    bcc.setBeanContext(null);
                }
                catch (PropertyVetoException e) {
                    // rewire the listeners we removed above then except
                    bcc.addPropertyChangeListener("beanContext", _childPcl);
                    bcc.addVetoableChangeListener("beanContext", _childVcl);
                    throw new IllegalStateException(e);
                }
            }
        }

        if (o instanceof BeanContextMembershipListener) {
            removeBeanContextMembershipListener((BeanContextMembershipListener) o);
        }

        BCChild bc = _children.get(o);
        if (bc.isProxy()) {
            _children.remove(bc.getChild());
        }
        else if (bc.hasProxy()) {
            _children.remove(bc.getProxy());
        }
        _children.remove(o);

        BeanContextMembershipEvent bcme = new BeanContextMembershipEvent((BeanContext) getPeer(), new Object[]{o});
        fireMembershipEvent(bcme, false);
        // end synchronized block
        return true;
    }
1014855
def remove(self):
        
        LOGGER.debug("Endpoint.remove - " + self.id + " - " + self.url)
        if self.id is None:
            return None
        else:
            if self.id in EndpointService.local_cache_by_id:
                for search_params in EndpointService.local_cache_by_id[self.id]:
                    if search_params in EndpointService.local_cache_by_params.keys():
                        EndpointService.local_cache_by_params.pop(search_params)
                EndpointService.local_cache_by_id.pop(self.id)

            params = SessionService.complete_transactional_req({
                'ID': self.id
            })

            if MappingService.driver_type != DriverFactory.DRIVER_REST:
                params['OPERATION'] = 'deleteEndpoint'
                args = {'properties': params}
            else:
                args = {'http_operation': 'GET', 'operation_path': 'delete', 'parameters': params}

            response = EndpointService.requester.call(args)

            if MappingService.driver_type != DriverFactory.DRIVER_REST:
                response = response.get()

            if response.rc != 0:
                LOGGER.warning(
                    'Endpoint.remove - Problem while deleting endpoint ' + str(self.id) +
                    'Reason: ' + str(response.response_content) + ' - ' + str(response.error_message) +
                    " (" + str(response.rc) + ")"
                )
                if response.rc == 500 and ArianeMappingOverloadError.ERROR_MSG in response.error_message:
                    raise ArianeMappingOverloadError("Endpoint.remove",
                                                     ArianeMappingOverloadError.ERROR_MSG)
                # traceback.print_stack()
                return self
            else:
                if self.parent_node is not None:
                    self.parent_node.sync()
                return None
240978
@Override
    public void removeProperty(Object description) {
        if (properties != null) {
            properties.remove(description);
            if (properties.isEmpty())
                properties = null;
        }
    }
987234
@Override
	public void removeByUuid(String uuid) {
		for (CPDefinitionOptionValueRel cpDefinitionOptionValueRel : findByUuid(
				uuid, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
			remove(cpDefinitionOptionValueRel);
		}
	}
301528
private boolean removeMapping(Object key, Object value) {
        Object k = maskNull(key);
        Object[] tab = table;
        int len = tab.length;
        int i = hash(k, len);

        while (true) {
            Object item = tab[i];
            if (item == k) {
                if (tab[i + 1] != value)
                    return false;
                modCount++;
                size--;
                tab[i] = null;
                tab[i + 1] = null;
                closeDeletion(i);
                return true;
            }
            if (item == null)
                return false;
            i = nextKeyIndex(i, len);
        }
    }
656955
public <T extends JobProperty> T removeProperty(Class<T> clazz) throws IOException {
        for (JobProperty<? super JobT> p : properties) {
            if (clazz.isInstance(p)) {
                removeProperty(p);
                return clazz.cast(p);
            }
        }
        return null;
    }
1135818
public static void removeDeepPropertyChangeListener(
        Object object, PropertyChangeListener propertyChangeListener)
    {
        Objects.requireNonNull(object, "The object may not be null");
        Objects.requireNonNull(propertyChangeListener, 
            "The propertyChangeListener may not be null");
        removeRecursive(object, propertyChangeListener);
    }
728878
@Override
    public void removeProperty(Property property) {
        properties.remove(property);
        property.removePropertyChangeListener(this);
        buildModel();
    }
169728
public <T> void clear(ElementDescriptor<T> property)
	{
		if (mRemove != null)
		{
			mRemove.remove(property);
		}

		if (mSet != null)
		{
			mSet.remove(property);
		}
	}
1025609
public void unregisterPropertyExclusion( Class target, String propertyName ) {
      if( target != null && propertyName != null ) {
         Set set = (Set) exclusionMap.get( target );
         if( set == null ) {
            set = new HashSet();
            exclusionMap.put( target, set );
         }
         set.remove( propertyName );
      }
   }
161861
static void filterUnwantedReferences(List<JpaProperty> result, Set<BeanId> query) {
        ListIterator<JpaProperty> it = result.listIterator();
        while (it.hasNext()) {
            // remove property from result that was not part of the query
            JpaProperty found = it.next();
            if (!query.contains(found.getId())) {
                it.remove();
            }
        }
    }
1156162
protected void removeBeanFromScratchMap() {
		Map<Object, Object> scratchMap = getBeanScratchMap();
		if (scratchMap == null) {
			return;
		}
		scratchMap.remove(SCRATCHMAP_BEAN_ID_KEY);
		scratchMap.remove(SCRATCHMAP_BEAN_OBJECT_KEY);
	}
737490
public int deleteValue(String property, String value) {
		int count = 0;
		if (has()) {
			Map<String, Object> fieldValues = buildFieldValues(property, value);
			count = getDao().delete(fieldValues);
		}
		return count;
	}
500969
@Override
    public void unset(String propName) {
        if (propName.equals("checkPoint")) {
            unsetCheckPoint();
        }
        if (propName.equals("changeTypes")) {
            unsetChangeTypes();
        }
        super.unset(propName);
    }
775036
public void remove() {
        if (polygon != null) {
            polygon.remove();
            polygon = null;
        }
        for (Marker marker : markers) {
            marker.remove();
        }
        for (PolygonHoleMarkers hole : holes) {
            hole.remove();
        }
    }
172264
public Object removeProperty( Object propertyId ) {
        return nodeProperties != null ? nodeProperties.remove(propertyId) : null;
    }