text:
package org.umlg.sqlg.structure.topology;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.google.common.base.Preconditions;
import org.apache.commons.collections4.set.ListOrderedSet;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Pair;
import org.apache.commons.lang3.tuple.Triple;
import org.apache.tinkerpop.gremlin.structure.Direction;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.umlg.sqlg.sql.dialect.SqlDialect;
import org.umlg.sqlg.structure.PropertyType;
import org.umlg.sqlg.structure.SchemaTable;
import org.umlg.sqlg.structure.SqlgGraph;
import org.umlg.sqlg.structure.TopologyChangeAction;
import org.umlg.sqlg.util.ThreadLocalMap;

import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

import static org.umlg.sqlg.structure.topology.Topology.*;

/**
 * Date: 2016/09/04
 * Time: 8:49 AM
 */
public class VertexLabel extends AbstractLabel {

    private static final Logger LOGGER = LoggerFactory.getLogger(VertexLabel.class);
    private final Schema schema;

    //hand (out) ----<label>---- finger (in)
    //The key of the map must include the schema.
    //This is A.A --ab-->A.B
    //        B.B --ab-->A.B
    //In this case 2 EdgeLabels will exist A.ab and B.ab
    //A.B's inEdgeLabels will contain both EdgeLabels
    final Map<String, EdgeLabel> inEdgeLabels = new ConcurrentHashMap<>();
    final Map<String, EdgeLabel> outEdgeLabels = new ConcurrentHashMap<>();
    private final Map<String, EdgeLabel> uncommittedInEdgeLabels = new ThreadLocalMap<>();
    private final Map<String, EdgeLabel> uncommittedOutEdgeLabels = new ThreadLocalMap<>();
    private final Map<String, Pair<EdgeLabel, EdgeRemoveType>> uncommittedRemovedInEdgeLabels = new ThreadLocalMap<>();
    private final Map<String, Pair<EdgeLabel, EdgeRemoveType>> uncommittedRemovedOutEdgeLabels = new ThreadLocalMap<>();

    private enum EdgeRemoveType {
        EDGE_LABEL,
        EDGE_ROLE
    }

    static VertexLabel createSqlgSchemaVertexLabel(Schema schema, String label, Map<String, PropertyType> columns) {
        Preconditions.checkArgument(schema.isSqlgSchema(), "createSqlgSchemaVertexLabel may only be called for \"%s\"", SQLG_SCHEMA);
        VertexLabel vertexLabel = new VertexLabel(schema, label);
        //Add the properties directly. As they are pre-created do not add them to uncommittedProperties.
        for (Map.Entry<String, PropertyType> propertyEntry : columns.entrySet()) {
            PropertyColumn property = new PropertyColumn(vertexLabel, propertyEntry.getKey(), propertyEntry.getValue());
            vertexLabel.properties.put(propertyEntry.getKey(), property);
        }
        return vertexLabel;
    }

    static VertexLabel createVertexLabel(SqlgGraph sqlgGraph, Schema schema, String label, Map<String, PropertyType> columns, ListOrderedSet<String> identifiers) {
        Preconditions.checkArgument(!schema.isSqlgSchema(), "createVertexLabel may not be called for \"%s\"", SQLG_SCHEMA);
        VertexLabel vertexLabel = new VertexLabel(schema, label, columns, identifiers);
        vertexLabel.createVertexLabelOnDb(columns, identifiers);
        TopologyManager.addVertexLabel(sqlgGraph, schema.getName(), label, columns, identifiers);
        vertexLabel.committed = false;
        return vertexLabel;
    }

    static VertexLabel renameVertexLabel(
            SqlgGraph sqlgGraph,
            Schema schema,
            String oldLabel,
            String newLabel,
            Map<String, PropertyType> columns,
            ListOrderedSet<String> identifiers) {

        Preconditions.checkArgument(!schema.isSqlgSchema(), "renameVertexLabel may not be called for \"%s\"", SQLG_SCHEMA);
        VertexLabel vertexLabel = new VertexLabel(schema, newLabel, columns, identifiers);
        vertexLabel.renameVertexLabelOnDb(oldLabel, newLabel);
        TopologyManager.renameVertexLabel(sqlgGraph, schema.getName(), VERTEX_PREFIX + oldLabel, VERTEX_PREFIX + newLabel);
        vertexLabel.committed = false;
        return vertexLabel;
    }

    static VertexLabel createPartitionedVertexLabel(
            SqlgGraph sqlgGraph,
            Schema schema,
            String label,
            Map<String, PropertyType> columns,
            ListOrderedSet<String> identifiers,
            PartitionType partitionType,
            String partitionExpression,
            boolean addPrimaryKeyConstraint) {

        Preconditions.checkArgument(!schema.isSqlgSchema(), "createVertexLabel may not be called for \"%s\"", SQLG_SCHEMA);
        Preconditions.checkArgument(partitionType != PartitionType.NONE, "PartitionType must be RANGE or LIST. Found NONE.");
        Preconditions.checkArgument(!StringUtils.isEmpty(partitionExpression), "partitionExpression may not be null or empty when creating a partitioned vertex label.");
        Preconditions.checkArgument(!identifiers.isEmpty(), "Partitioned label must have at least one identifier.");
        VertexLabel vertexLabel = new VertexLabel(schema, label, columns, identifiers, partitionType, partitionExpression);
        vertexLabel.createPartitionedVertexLabelOnDb(columns, identifiers, addPrimaryKeyConstraint);
        TopologyManager.addVertexLabel(sqlgGraph, schema.getName(), label, columns, identifiers, partitionType, partitionExpression);
        vertexLabel.committed = false;
        return vertexLabel;
    }

    VertexLabel(Schema schema, String label) {
        super(schema.getSqlgGraph(), label);
        this.schema = schema;
    }

    VertexLabel(Schema schema, String label, boolean isForeignVertexLabel) {
        super(schema.getSqlgGraph(), label, isForeignVertexLabel);
        this.schema = schema;
    }

    /**
     * Only called for a new label being added.
     *
     * @param schema     The schema.
     * @param label      The vertex's label.
     * @param properties The vertex's properties.
     */
    private VertexLabel(Schema schema, String label, Map<String, PropertyType> properties, ListOrderedSet<String> identifiers) {
        super(schema.getSqlgGraph(), label, properties, identifiers);
        this.schema = schema;
    }

    /**
     * Called for a partitioned vertex label loaded on startup.
     *
     * @param schema        The schema.
     * @param label         The vertex's label.
     * @param partitionType The vertex's partition strategy. i.e. RANGE or LIST.
     */
    VertexLabel(Schema schema, String label, PartitionType partitionType, String partitionExpression) {
        super(schema.getSqlgGraph(), label, partitionType, partitionExpression);
        this.schema = schema;
    }

    /**
     * Called for a new partitioned vertex label being added and when partitioned vertices are loaded on startup.
     *
     * @param schema        The schema.
     * @param label         The vertex's label.
     * @param properties    The vertex's properties.
     * @param identifiers   The vertex's identifiers.
     * @param partitionType The vertex's partition strategy. i.e. RANGE or LIST.
     */
    VertexLabel(Schema schema, String label, Map<String, PropertyType> properties, ListOrderedSet<String> identifiers, PartitionType partitionType, String partitionExpression) {
        super(schema.getSqlgGraph(), label, properties, identifiers, partitionType, partitionExpression);
        this.schema = schema;
    }

    @Override
    public Schema getSchema() {
        return this.schema;
    }

    @Override
    public Topology getTopology() {
        return this.schema.getTopology();
    }

    public Map<String, EdgeLabel> getInEdgeLabels() {
        Map<String, EdgeLabel> result = new HashMap<>(this.inEdgeLabels);
        if (this.schema.getTopology().isSchemaChanged()) {
            result.putAll(this.uncommittedInEdgeLabels);
            for (String e : this.uncommittedRemovedInEdgeLabels.keySet()) {
                result.remove(e);
            }
        }
        return result;
    }

    public Map<String, EdgeLabel> getOutEdgeLabels() {
        Map<String, EdgeLabel> result = new HashMap<>(this.outEdgeLabels);
        if (this.schema.getTopology().isSchemaChanged()) {
            result.putAll(this.uncommittedOutEdgeLabels);
            for (String e : this.uncommittedRemovedOutEdgeLabels.keySet()) {
                result.remove(e);
            }
        }
        return Collections.unmodifiableMap(result);
    }

    public Map<String, EdgeRole> getInEdgeRoles() {
        Map<String, EdgeRole> result = new HashMap<>();
        for (String k : this.inEdgeLabels.keySet()) {
            result.put(k, new EdgeRole(this, this.inEdgeLabels.get(k), Direction.IN, true));
        }
        if (this.schema.getTopology().isSchemaChanged()) {
            for (String k : this.uncommittedInEdgeLabels.keySet()) {
                result.put(k, new EdgeRole(this, this.uncommittedInEdgeLabels.get(k), Direction.IN, false));
            }
            for (String e : this.uncommittedRemovedInEdgeLabels.keySet()) {
                result.remove(e);
            }
        }
        return Collections.unmodifiableMap(result);
    }

    public Map<String, EdgeRole> getOutEdgeRoles() {
        Map<String, EdgeRole> result = new HashMap<>();
        for (String k : this.outEdgeLabels.keySet()) {
            result.put(k, new EdgeRole(this, this.outEdgeLabels.get(k), Direction.OUT, true));
        }
        if (this.schema.getTopology().isSchemaChanged()) {
            for (String k : this.uncommittedOutEdgeLabels.keySet()) {
                result.put(k, new EdgeRole(this, this.uncommittedOutEdgeLabels.get(k), Direction.OUT, false));
            }
            for (String e : this.uncommittedRemovedOutEdgeLabels.keySet()) {
                result.remove(e);
            }
        }
        return Collections.unmodifiableMap(result);
    }

    /**
     * Out EdgeLabels are always in the same schema as the 'this' VertexLabel' schema.
     * So the edgeLabelName must not contain the schema prefix
     *
     * @param edgeLabelName The edge label's name
     * @return Optionally the EdgeLabel
     */
    public Optional<EdgeLabel> getOutEdgeLabel(String edgeLabelName) {
        EdgeLabel edgeLabel = getOutEdgeLabels().get(this.schema.getName() + "." + edgeLabelName);
        if (edgeLabel != null) {
            return Optional.of(edgeLabel);
        }
        return Optional.empty();
    }

    /**
     * A getter for a map of all uncommitted {@link EdgeLabel}s. This may include {@link EdgeLabel}s that are already
     * committed but that contain uncommitted properties.
     * This will only return something if the current thread has the write lock.
     *
     * @return A map of uncommitted EdgeLabels. The map key is the EdgeLabels label.
     */
    Map<String, EdgeLabel> getUncommittedOutEdgeLabels() {
        if (this.schema.getTopology().isSchemaChanged()) {
            Map<String, EdgeLabel> result = new HashMap<>(this.uncommittedOutEdgeLabels);
            for (EdgeLabel outEdgeLabel : this.outEdgeLabels.values()) {
                Map<String, PropertyColumn> propertyMap = outEdgeLabel.getUncommittedPropertyTypeMap();
                if (!propertyMap.isEmpty() || !outEdgeLabel.getUncommittedRemovedProperties().isEmpty()) {
                    result.put(outEdgeLabel.getLabel(), outEdgeLabel);
                }
            }
            return Collections.unmodifiableMap(result);
        } else {
            return Collections.emptyMap();
        }
    }

    Optional<EdgeLabel> getUncommittedOutEdgeLabel(String edgeLabelName) {
        if (this.schema.getTopology().isSchemaChanged()) {
            EdgeLabel edgeLabel = this.getUncommittedOutEdgeLabels().get(edgeLabelName);
            if (edgeLabel != null) {
                return Optional.of(edgeLabel);
            }
        }
        return Optional.empty();
    }

    void addToUncommittedInEdgeLabels(Schema schema, EdgeLabel edgeLabel) {
        this.uncommittedInEdgeLabels.put(schema.getName() + "." + edgeLabel.getLabel(), edgeLabel);
    }

    void addToUncommittedOutEdgeLabels(Schema schema, EdgeLabel edgeLabel) {
        this.uncommittedOutEdgeLabels.put(schema.getName() + "." + edgeLabel.getLabel(), edgeLabel);
    }

    /**
     * Called from {@link Topology#Topology(SqlgGraph)}s constructor to preload the sqlg_schema.
     * This can only be called for sqlg_schema.
     *
     * @param edgeLabelName The edge's label.
     * @param inVertexLabel The edge's in {@link VertexLabel}. 'this' is the out {@link VertexLabel}.
     * @param properties    A map of the edge's properties.
     */
    void loadSqlgSchemaEdgeLabel(String edgeLabelName, VertexLabel inVertexLabel, Map<String, PropertyType> properties) {
        Preconditions.checkState(this.schema.isSqlgSchema(), "loadSqlgSchemaEdgeLabel must be called for \"%s\" found \"%s\"", SQLG_SCHEMA, this.schema.getName());
        EdgeLabel edgeLabel = EdgeLabel.loadSqlgSchemaEdgeLabel(edgeLabelName, this, inVertexLabel, properties);
        this.outEdgeLabels.put(this.schema.getName() + "." + edgeLabel.getLabel(), edgeLabel);
        inVertexLabel.inEdgeLabels.put(this.schema.getName() + "." + edgeLabel.getLabel(), edgeLabel);
    }

    /**
     * Ensures that the {@link EdgeLabel} exists. It will be created if it does not exists.
     * "this" is the out {@link VertexLabel} and inVertexLabel is the inVertexLabel
     * This method is equivalent to {@link Schema#ensureEdgeLabelExist(String, VertexLabel, VertexLabel, Map)}
     *
     * @param edgeLabelName The EdgeLabel's label's name.
     * @param inVertexLabel The edge's in VertexLabel.
     * @return The {@link EdgeLabel}.
     */
    public EdgeLabel ensureEdgeLabelExist(final String edgeLabelName, final VertexLabel inVertexLabel) {
        return this.getSchema().ensureEdgeLabelExist(edgeLabelName, this, inVertexLabel, Collections.emptyMap());
    }

    /**
     * Ensures that the {@link EdgeLabel} exists. It will be created if it does not exists.
     * "this" is the out {@link VertexLabel} and inVertexLabel is the inVertexLabel
     * This method is equivalent to {@link Schema#ensureEdgeLabelExist(String, VertexLabel, VertexLabel, Map)}
     *
     * @param edgeLabelName The EdgeLabel's label's name.
     * @param inVertexLabel The edge's in VertexLabel.
     * @param properties    The EdgeLabel's properties
     * @return The EdgeLabel
     */
    public EdgeLabel ensureEdgeLabelExist(final String edgeLabelName, final VertexLabel inVertexLabel, Map<String, PropertyType> properties) {
        return this.getSchema().ensureEdgeLabelExist(edgeLabelName, this, inVertexLabel, properties);
    }

    /**
     * Ensures that the {@link EdgeLabel} exists. It will be created if it does not exists.
     * "this" is the out {@link VertexLabel} and inVertexLabel is the inVertexLabel
     * This method is equivalent to {@link Schema#ensureEdgeLabelExist(String, VertexLabel, VertexLabel, Map, ListOrderedSet)}
     *
     * @param edgeLabelName The EdgeLabel's label's name.
     * @param inVertexLabel The edge's in VertexLabel.
     * @param properties    The EdgeLabel's properties.
     * @param identifiers   The EdgeLabel's identifiers.
     * @return The EdgeLabel
     */
    public EdgeLabel ensureEdgeLabelExist(final String edgeLabelName, final VertexLabel inVertexLabel, Map<String, PropertyType> properties, ListOrderedSet<String> identifiers) {
        return this.getSchema().ensureEdgeLabelExist(edgeLabelName, this, inVertexLabel, properties, identifiers);
    }

    public EdgeLabel ensurePartitionedEdgeLabelExist(
            final String edgeLabelName,
            final VertexLabel inVertexLabel,
            Map<String, PropertyType> properties,
            ListOrderedSet<String> identifiers,
            PartitionType partitionType,
            String partitionExpression,
            boolean isForeignKeyPartition) {

        return this.getSchema().ensurePartitionedEdgeLabelExist(
                edgeLabelName,
                this,
                inVertexLabel,
                properties,
                identifiers,
                partitionType,
                partitionExpression,
                isForeignKeyPartition
        );
    }

    public EdgeLabel ensurePartitionedEdgeLabelExist(
            final String edgeLabelName,
            final VertexLabel inVertexLabel,
            Map<String, PropertyType> properties,
            ListOrderedSet<String> identifiers,
            PartitionType partitionType,
            String partitionExpression) {

        return this.getSchema().ensurePartitionedEdgeLabelExist(
                edgeLabelName,
                this,
                inVertexLabel,
                properties,
                identifiers,
                partitionType,
                partitionExpression);
    }

    EdgeLabel addPartitionedEdgeLabel(
            final String edgeLabelName,
            final VertexLabel inVertexLabel,
            final Map<String, PropertyType> properties,
            final ListOrderedSet<String> identifiers,
            final PartitionType partitionType,
            final String partitionExpression,
            boolean isForeignKeyPartition) {

        EdgeLabel edgeLabel = EdgeLabel.createPartitionedEdgeLabel(
                edgeLabelName,
                this,
                inVertexLabel,
                properties,
                identifiers,
                partitionType,
                partitionExpression,
                isForeignKeyPartition);
        if (this.schema.isSqlgSchema()) {
            this.outEdgeLabels.put(this.schema.getName() + "." + edgeLabel.getLabel(), edgeLabel);
            inVertexLabel.inEdgeLabels.put(this.schema.getName() + "." + edgeLabel.getLabel(), edgeLabel);
        } else {
            this.uncommittedOutEdgeLabels.put(this.schema.getName() + "." + edgeLabel.getLabel(), edgeLabel);
            inVertexLabel.uncommittedInEdgeLabels.put(this.schema.getName() + "." + edgeLabel.getLabel(), edgeLabel);
        }
        return edgeLabel;
    }

    /**
     * Called via {@link Schema#ensureEdgeLabelExist(String, VertexLabel, VertexLabel, Map)}
     * This is called when the {@link EdgeLabel} does not exist and needs to be created.
     *
     * @param edgeLabelName The edge's label.
     * @param inVertexLabel The edge's in vertex.
     * @param properties    The edge's properties.
     * @return The new EdgeLabel.
     */
    EdgeLabel addEdgeLabel(
            String edgeLabelName,
            VertexLabel inVertexLabel,
            Map<String, PropertyType> properties) {
        return addEdgeLabel(edgeLabelName, inVertexLabel, properties, new ListOrderedSet<>());
    }

    /**
     * Called via {@link Schema#ensureEdgeLabelExist(String, VertexLabel, VertexLabel, Map)}
     * This is called when the {@link EdgeLabel} does not exist and needs to be created.
     *
     * @param edgeLabelName The edge's label.
     * @param inVertexLabel The edge's in vertex.
     * @param properties    The edge's properties.
     * @param identifiers   The edge's user defined identifiers.
     * @return The new EdgeLabel.
     */
    EdgeLabel addEdgeLabel(
            String edgeLabelName,
            VertexLabel inVertexLabel,
            Map<String, PropertyType> properties,
            ListOrderedSet<String> identifiers) {

        EdgeLabel edgeLabel = EdgeLabel.createEdgeLabel(edgeLabelName, this, inVertexLabel, properties, identifiers);
        if (this.schema.isSqlgSchema()) {
            this.outEdgeLabels.put(this.schema.getName() + "." + edgeLabel.getLabel(), edgeLabel);
            inVertexLabel.inEdgeLabels.put(this.schema.getName() + "." + edgeLabel.getLabel(), edgeLabel);
        } else {
            this.uncommittedOutEdgeLabels.put(this.schema.getName() + "." + edgeLabel.getLabel(), edgeLabel);
            inVertexLabel.uncommittedInEdgeLabels.put(this.schema.getName() + "." + edgeLabel.getLabel(), edgeLabel);
        }
        return edgeLabel;
    }

    //    @Override
    public void ensurePropertiesExist(Map<String, PropertyType> columns) {
        for (Map.Entry<String, PropertyType> column : columns.entrySet()) {
            if (!this.properties.containsKey(column.getKey())) {
                Preconditions.checkState(!this.isForeignAbstractLabel, "'%s' is a read only foreign VertexLabel!", this.label);
                Preconditions.checkState(!this.schema.isSqlgSchema(), "schema may not be %s", SQLG_SCHEMA);
                this.sqlgGraph.getSqlDialect().validateColumnName(column.getKey());
                if (!this.uncommittedProperties.containsKey(column.getKey())) {
                    this.schema.getTopology().startSchemaChange();
                    if (getProperty(column.getKey()).isEmpty()) {
                        TopologyManager.addVertexColumn(this.sqlgGraph, this.schema.getName(), VERTEX_PREFIX + getLabel(), column);
                        addColumn(this.schema.getName(), VERTEX_PREFIX + getLabel(), ImmutablePair.of(column.getKey(), column.getValue()));
                        PropertyColumn propertyColumn = new PropertyColumn(this, column.getKey(), column.getValue());
                        propertyColumn.setCommitted(false);
                        this.uncommittedProperties.put(column.getKey(), propertyColumn);
                        this.getSchema().getTopology().fire(propertyColumn, null, TopologyChangeAction.CREATE);
                    }
                }
            }
        }
    }

    public void ensureDistributed(int shardCount, PropertyColumn distributionPropertyColumn) {
        ensureDistributed(shardCount, distributionPropertyColumn, null);
    }

    public void ensureDistributed(PropertyColumn distributionPropertyColumn, AbstractLabel colocate) {
        ensureDistributed(-1, distributionPropertyColumn, colocate);
    }

    private void createVertexLabelOnDb(Map<String, PropertyType> columns, ListOrderedSet<String> identifiers) {
        StringBuilder sql = new StringBuilder(this.sqlgGraph.getSqlDialect().createTableStatement());
        sql.append(this.sqlgGraph.getSqlDialect().maybeWrapInQoutes(this.schema.getName()));
        sql.append(".");
        sql.append(this.sqlgGraph.getSqlDialect().maybeWrapInQoutes(VERTEX_PREFIX + getLabel()));
        sql.append(" (");

        if (identifiers.isEmpty()) {
            sql.append(this.sqlgGraph.getSqlDialect().maybeWrapInQoutes("ID"));
            sql.append(" ");
            sql.append(this.sqlgGraph.getSqlDialect().getAutoIncrementPrimaryKeyConstruct());
            if (columns.size() > 0) {
                sql.append(", ");
            }
        }
        buildColumns(this.sqlgGraph, identifiers, columns, sql);
        if (!identifiers.isEmpty()) {
            sql.append(", PRIMARY KEY(");
            int count = 1;
            for (String identifier : identifiers) {
                sql.append(this.sqlgGraph.getSqlDialect().maybeWrapInQoutes(identifier));
                if (count++ < identifiers.size()) {
                    sql.append(", ");
                }
            }
            sql.append(")");
        }
        sql.append(")");
        if (this.sqlgGraph.getSqlDialect().needsSemicolon()) {
            sql.append(";");
        }
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug(sql.toString());
        }
        Connection conn = this.sqlgGraph.tx().getConnection();
        try (Statement stmt = conn.createStatement()) {
            stmt.execute(sql.toString());
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    private void renameVertexLabelOnDb(String oldLabel, String newLabel) {
        String sql = this.sqlgGraph.getSqlDialect().renameTable(
                this.schema.getName(),
                VERTEX_PREFIX + oldLabel,
                VERTEX_PREFIX + newLabel
        );
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug(sql);
        }
        Connection conn = this.sqlgGraph.tx().getConnection();
        try (Statement stmt = conn.createStatement()) {
            stmt.execute(sql);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    private void createPartitionedVertexLabelOnDb(Map<String, PropertyType> columns, ListOrderedSet<String> identifiers, boolean addPrimaryKeyConstraint) {
        Preconditions.checkState(!identifiers.isEmpty(), "Partitioned table must have identifiers.");
        StringBuilder sql = new StringBuilder(this.sqlgGraph.getSqlDialect().createTableStatement());
        sql.append(this.sqlgGraph.getSqlDialect().maybeWrapInQoutes(this.schema.getName()));
        sql.append(".");
        sql.append(this.sqlgGraph.getSqlDialect().maybeWrapInQoutes(VERTEX_PREFIX + getLabel()));
        sql.append(" (");
        buildColumns(this.sqlgGraph, new ListOrderedSet<>(), columns, sql);

        //below is needed for #408, to create the primary key.
        //It however clashes with existing partitioned table definitions.
        if (addPrimaryKeyConstraint) {
            sql.append(", PRIMARY KEY(");
            int count = 1;
            for (String identifier : identifiers) {
                sql.append(this.sqlgGraph.getSqlDialect().maybeWrapInQoutes(identifier));
                if (count++ < identifiers.size()) {
                    sql.append(", ");
                }
            }
            sql.append(")");
        }

        //nothing to do with the identifiers as partitioned tables do not have primary keys.
        sql.append(") PARTITION BY ");
        sql.append(this.partitionType.name());
        sql.append(" (");
        sql.append(this.partitionExpression);
        sql.append(")");
        if (this.sqlgGraph.getSqlDialect().needsSemicolon()) {
            sql.append(";");
        }
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug(sql.toString());
        }
        Connection conn = this.sqlgGraph.tx().getConnection();
        try (Statement stmt = conn.createStatement()) {
            stmt.execute(sql.toString());
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    //TODO refactor to not use SchemaTable at this level
    Pair<Set<SchemaTable>, Set<SchemaTable>> getTableLabels() {
        Set<SchemaTable> inSchemaTables = new HashSet<>();
        Set<SchemaTable> outSchemaTables = new HashSet<>();
        for (EdgeLabel inEdgeLabel : this.inEdgeLabels.values()) {
            inSchemaTables.add(SchemaTable.of(inEdgeLabel.getSchema().getName(), EDGE_PREFIX + inEdgeLabel.getLabel()));
        }
        for (EdgeLabel outEdgeLabel : this.outEdgeLabels.values()) {
            outSchemaTables.add(SchemaTable.of(outEdgeLabel.getSchema().getName(), EDGE_PREFIX + outEdgeLabel.getLabel()));
        }
        if (this.schema.getTopology().isSchemaChanged()) {
            for (EdgeLabel inEdgeLabel : this.uncommittedInEdgeLabels.values()) {
                inSchemaTables.add(SchemaTable.of(inEdgeLabel.getSchema().getName(), EDGE_PREFIX + inEdgeLabel.getLabel()));
            }
            for (EdgeLabel outEdgeLabel : this.uncommittedOutEdgeLabels.values()) {
                outSchemaTables.add(SchemaTable.of(outEdgeLabel.getSchema().getName(), EDGE_PREFIX + outEdgeLabel.getLabel()));
            }
        }
        return Pair.of(inSchemaTables, outSchemaTables);
    }

    void afterCommit() {
        Preconditions.checkState(this.schema.getTopology().isSchemaChanged(), "VertexLabel.afterCommit must have schemaChanged = true");
        super.afterCommit();
        Iterator<Map.Entry<String, EdgeLabel>> edgeLabelEntryIter = this.uncommittedOutEdgeLabels.entrySet().iterator();
        while (edgeLabelEntryIter.hasNext()) {
            Map.Entry<String, EdgeLabel> edgeLabelEntry = edgeLabelEntryIter.next();
            String edgeLabelName = edgeLabelEntry.getKey();
            EdgeLabel edgeLabel = edgeLabelEntry.getValue();
            this.outEdgeLabels.put(edgeLabelName, edgeLabel);
            edgeLabel.afterCommit();
            this.getSchema().addToAllEdgeCache(edgeLabel);
            edgeLabelEntryIter.remove();
        }
        edgeLabelEntryIter = this.uncommittedInEdgeLabels.entrySet().iterator();
        while (edgeLabelEntryIter.hasNext()) {
            Map.Entry<String, EdgeLabel> edgeLabelEntry = edgeLabelEntryIter.next();
            String edgeLabelName = edgeLabelEntry.getKey();
            EdgeLabel edgeLabel = edgeLabelEntry.getValue();
            this.inEdgeLabels.put(edgeLabelName, edgeLabel);
            edgeLabel.afterCommit();
            edgeLabelEntryIter.remove();

        }
        for (Iterator<String> it = this.uncommittedRemovedOutEdgeLabels.keySet().iterator(); it.hasNext(); ) {
            String s = it.next();
            EdgeLabel lbl = this.outEdgeLabels.remove(s);
            if (lbl != null) {
                ForeignKey foreignKey;
                if (hasIDPrimaryKey()) {
                    foreignKey = ForeignKey.of(this.getFullName() + Topology.OUT_VERTEX_COLUMN_END);
                } else {
                    foreignKey = new ForeignKey();
                    for (String identifier : this.getIdentifiers()) {
                        foreignKey.add(this.getFullName(), identifier, Topology.OUT_VERTEX_COLUMN_END);
                    }
                }
                this.getSchema().getTopology().removeFromEdgeForeignKeyCache(
                        lbl.getSchema().getName() + "." + EDGE_PREFIX + lbl.getLabel(),
                        foreignKey);
                this.getSchema().getTopology().removeOutForeignKeysFromVertexLabel(this, lbl);

            }
            it.remove();
        }

        for (Iterator<String> it = this.uncommittedRemovedInEdgeLabels.keySet().iterator(); it.hasNext(); ) {
            String s = it.next();
            EdgeLabel lbl = this.inEdgeLabels.remove(s);
            if (lbl != null) {
                ForeignKey foreignKey;
                if (this.hasIDPrimaryKey()) {
                    foreignKey = ForeignKey.of(this.getFullName() + Topology.IN_VERTEX_COLUMN_END);
                } else {
                    foreignKey = new ForeignKey();
                    for (String identifier : this.getIdentifiers()) {
                        foreignKey.add(this.getFullName(), identifier, Topology.IN_VERTEX_COLUMN_END);
                    }
                }
                this.getSchema().getTopology().removeFromEdgeForeignKeyCache(
                        lbl.getSchema().getName() + "." + EDGE_PREFIX + lbl.getLabel(),
                        foreignKey);
                this.getSchema().getTopology().removeInForeignKeysFromVertexLabel(this, lbl);
            }
            it.remove();
        }

        for (EdgeLabel edgeLabel : this.outEdgeLabels.values()) {
            edgeLabel.afterCommit();
        }
        for (EdgeLabel edgeLabel : this.inEdgeLabels.values()) {
            edgeLabel.afterCommit();
        }
    }

    void afterRollbackForInEdges() {
        Preconditions.checkState(this.schema.getTopology().isSchemaChanged(), "VertexLabel.afterRollback must have schemaChanged = true");
        super.afterRollback();
        for (Iterator<EdgeLabel> it = this.uncommittedInEdgeLabels.values().iterator(); it.hasNext(); ) {
            EdgeLabel edgeLabel = it.next();
            edgeLabel.afterRollbackInEdges(this);
            it.remove();
        }
        for (EdgeLabel edgeLabel : this.inEdgeLabels.values()) {
            edgeLabel.afterRollbackInEdges(this);
            this.uncommittedRemovedInEdgeLabels.remove(edgeLabel.getFullName());
        }
    }

    void afterRollbackForOutEdges() {
        Preconditions.checkState(this.schema.getTopology().isSchemaChanged(), "VertexLabel.afterRollback must have schemaChanged = true");
        super.afterRollback();
        for (Iterator<EdgeLabel> it = this.uncommittedOutEdgeLabels.values().iterator(); it.hasNext(); ) {
            EdgeLabel edgeLabel = it.next();
            it.remove();
            //It is important to first remove the EdgeLabel from the iterator as the EdgeLabel's outVertex is still
            // present and its needed for the hashCode method which is invoked during the it.remove()
            edgeLabel.afterRollbackOutEdges(this);
        }
        for (EdgeLabel edgeLabel : this.outEdgeLabels.values()) {
            edgeLabel.afterRollbackOutEdges(this);
            this.uncommittedRemovedOutEdgeLabels.remove(edgeLabel.getFullName());
        }
    }

    @Override
    public String toString() {
        return toJson().toString();
    }

    void addToOutEdgeLabels(String schema, EdgeLabel edgeLabel) {
        edgeLabel.addToOutVertexLabel(this);
        this.outEdgeLabels.put(schema + "." + edgeLabel.getLabel(), edgeLabel);
    }

    void addToInEdgeLabels(EdgeLabel edgeLabel) {
        edgeLabel.addToInVertexLabel(this);
        this.inEdgeLabels.put(edgeLabel.getSchema().getName() + "." + edgeLabel.getLabel(), edgeLabel);
    }

    @Override
    protected JsonNode toJson() {
        ObjectNode vertexLabelNode = new ObjectNode(Topology.OBJECT_MAPPER.getNodeFactory());
        vertexLabelNode.put("schema", getSchema().getName());
        vertexLabelNode.put("label", getLabel());
        vertexLabelNode.set("properties", super.toJson());

        ArrayNode outEdgeLabelsArrayNode = new ArrayNode(Topology.OBJECT_MAPPER.getNodeFactory());
        List<EdgeLabel> edgeLabels = new ArrayList<>(this.outEdgeLabels.values());
        edgeLabels.sort(Comparator.comparing(EdgeLabel::getName));
        for (EdgeLabel edgeLabel : edgeLabels) {
            outEdgeLabelsArrayNode.add(edgeLabel.toJson());
        }
        vertexLabelNode.set("outEdgeLabels", outEdgeLabelsArrayNode);

        ArrayNode inEdgeLabelsArrayNode = new ArrayNode(Topology.OBJECT_MAPPER.getNodeFactory());
        edgeLabels = new ArrayList<>(this.inEdgeLabels.values());
        edgeLabels.sort(Comparator.comparing(EdgeLabel::getName));
        for (EdgeLabel edgeLabel : edgeLabels) {
            inEdgeLabelsArrayNode.add(edgeLabel.toJson());
        }
        vertexLabelNode.set("inEdgeLabels", inEdgeLabelsArrayNode);

        ArrayNode partitionArrayNode = new ArrayNode(Topology.OBJECT_MAPPER.getNodeFactory());
        for (Partition partition : this.getPartitions().values()) {
            Optional<ObjectNode> json = partition.toJson();
            json.ifPresent(partitionArrayNode::add);
        }
        vertexLabelNode.set("partitions", partitionArrayNode);

        if (this.schema.getTopology().isSchemaChanged()) {
            outEdgeLabelsArrayNode = new ArrayNode(Topology.OBJECT_MAPPER.getNodeFactory());
            edgeLabels = new ArrayList<>(this.uncommittedOutEdgeLabels.values());
            edgeLabels.sort(Comparator.comparing(EdgeLabel::getName));
            for (EdgeLabel edgeLabel : edgeLabels) {
                outEdgeLabelsArrayNode.add(edgeLabel.toJson());
            }
            vertexLabelNode.set("uncommittedOutEdgeLabels", outEdgeLabelsArrayNode);

            inEdgeLabelsArrayNode = new ArrayNode(Topology.OBJECT_MAPPER.getNodeFactory());
            edgeLabels = new ArrayList<>(this.uncommittedInEdgeLabels.values());
            edgeLabels.sort(Comparator.comparing(EdgeLabel::getName));
            for (EdgeLabel edgeLabel : edgeLabels) {
                inEdgeLabelsArrayNode.add(edgeLabel.toJson());
            }
            vertexLabelNode.set("uncommittedInEdgeLabels", inEdgeLabelsArrayNode);
        }
        return vertexLabelNode;
    }

    protected Optional<JsonNode> toNotifyJson() {
        ObjectNode vertexLabelNode = new ObjectNode(Topology.OBJECT_MAPPER.getNodeFactory());
        vertexLabelNode.put("label", getLabel());
        vertexLabelNode.put("partitionType", this.partitionType.name());
        vertexLabelNode.put("partitionExpression", this.partitionExpression);

        Optional<JsonNode> abstractLabelNode = super.toNotifyJson();
        if (abstractLabelNode.isPresent()) {
            vertexLabelNode.set("uncommittedProperties", abstractLabelNode.get().get("uncommittedProperties"));
            vertexLabelNode.set("uncommittedIdentifiers", abstractLabelNode.get().get("uncommittedIdentifiers"));
            vertexLabelNode.set("renamedIdentifiers", abstractLabelNode.get().get("renamedIdentifiers"));
            vertexLabelNode.set("uncommittedPartitions", abstractLabelNode.get().get("uncommittedPartitions"));
            vertexLabelNode.set("uncommittedPartitions", abstractLabelNode.get().get("uncommittedPartitions"));
            if (abstractLabelNode.get().get("uncommittedDistributionPropertyColumn") != null) {
                vertexLabelNode.set("uncommittedDistributionPropertyColumn", abstractLabelNode.get().get("uncommittedDistributionPropertyColumn"));
            }
            if (abstractLabelNode.get().get("uncommittedShardCount") != null) {
                vertexLabelNode.set("uncommittedShardCount", abstractLabelNode.get().get("uncommittedShardCount"));
            }
            if (abstractLabelNode.get().get("uncommittedDistributionColocateAbstractLabel") != null) {
                vertexLabelNode.set("uncommittedDistributionColocateAbstractLabel", abstractLabelNode.get().get("uncommittedDistributionColocateAbstractLabel"));
            }
            vertexLabelNode.set("partitions", abstractLabelNode.get().get("partitions"));
            vertexLabelNode.set("uncommittedIndexes", abstractLabelNode.get().get("uncommittedIndexes"));
            vertexLabelNode.set("uncommittedRemovedProperties", abstractLabelNode.get().get("uncommittedRemovedProperties"));
            vertexLabelNode.set("uncommittedRemovedPartitions", abstractLabelNode.get().get("uncommittedRemovedPartitions"));
            vertexLabelNode.set("uncommittedRemovedIndexes", abstractLabelNode.get().get("uncommittedRemovedIndexes"));
        }

        if (this.schema.getTopology().isSchemaChanged() && !this.uncommittedOutEdgeLabels.isEmpty()) {
            ArrayNode outEdgeLabelsArrayNode = new ArrayNode(Topology.OBJECT_MAPPER.getNodeFactory());
            for (EdgeLabel edgeLabel : this.uncommittedOutEdgeLabels.values()) {
                Optional<JsonNode> jsonNodeOptional = edgeLabel.toNotifyJson();
                Preconditions.checkState(jsonNodeOptional.isPresent(), "There must be data to notify as the edgeLabel itself is uncommitted");
                outEdgeLabelsArrayNode.add(jsonNodeOptional.get());
            }
            vertexLabelNode.set("uncommittedOutEdgeLabels", outEdgeLabelsArrayNode);
        }

        if (this.schema.getTopology().isSchemaChanged() && !this.uncommittedRemovedOutEdgeLabels.isEmpty()) {
            ArrayNode outEdgeLabelsArrayNode = new ArrayNode(Topology.OBJECT_MAPPER.getNodeFactory());
            for (String edgeLabel : this.uncommittedRemovedOutEdgeLabels.keySet()) {
                ObjectNode edgeRemove = new ObjectNode(Topology.OBJECT_MAPPER.getNodeFactory());
                edgeRemove.put("label", edgeLabel);
                edgeRemove.put("type", this.uncommittedRemovedOutEdgeLabels.get(edgeLabel).getRight().name());
                outEdgeLabelsArrayNode.add(edgeRemove);
            }
            vertexLabelNode.set("uncommittedRemovedOutEdgeLabels", outEdgeLabelsArrayNode);
        }

        if (this.schema.getTopology().isSchemaChanged() && !this.uncommittedInEdgeLabels.isEmpty()) {
            ArrayNode inEdgeLabelsArrayNode = new ArrayNode(Topology.OBJECT_MAPPER.getNodeFactory());
            for (EdgeLabel edgeLabel : this.uncommittedInEdgeLabels.values()) {
                Optional<JsonNode> jsonNodeOptional = edgeLabel.toNotifyJson();
                Preconditions.checkState(jsonNodeOptional.isPresent(), "There must be data to notify as the edgeLabel itself is uncommitted");
                inEdgeLabelsArrayNode.add(jsonNodeOptional.get());
            }
            vertexLabelNode.set("uncommittedInEdgeLabels", inEdgeLabelsArrayNode);
        }

        if (this.schema.getTopology().isSchemaChanged() && !this.uncommittedRemovedInEdgeLabels.isEmpty()) {
            ArrayNode outEdgeLabelsArrayNode = new ArrayNode(Topology.OBJECT_MAPPER.getNodeFactory());
            for (String edgeLabel : this.uncommittedRemovedInEdgeLabels.keySet()) {
                ObjectNode edgeRemove = new ObjectNode(Topology.OBJECT_MAPPER.getNodeFactory());
                edgeRemove.put("label", edgeLabel);
                edgeRemove.put("type", this.uncommittedRemovedInEdgeLabels.get(edgeLabel).getRight().name());
                outEdgeLabelsArrayNode.add(edgeRemove);
            }
            vertexLabelNode.set("uncommittedRemovedInEdgeLabels", outEdgeLabelsArrayNode);
        }

        //check for uncommittedProperties in existing edges
        ArrayNode outEdgeLabelsArrayNode = new ArrayNode(Topology.OBJECT_MAPPER.getNodeFactory());
        boolean foundOutEdgeLabel = false;
        for (EdgeLabel edgeLabel : this.outEdgeLabels.values()) {
            Optional<JsonNode> jsonNodeOptional = edgeLabel.toNotifyJson();
            if (jsonNodeOptional.isPresent()) {
                foundOutEdgeLabel = true;
                outEdgeLabelsArrayNode.add(jsonNodeOptional.get());
            }
        }
        if (foundOutEdgeLabel) {
            vertexLabelNode.set("outEdgeLabels", outEdgeLabelsArrayNode);
        }

        ArrayNode inEdgeLabelsArrayNode = new ArrayNode(Topology.OBJECT_MAPPER.getNodeFactory());
        boolean foundInEdgeLabels = false;
        for (EdgeLabel edgeLabel : this.inEdgeLabels.values()) {
            if (edgeLabel.isValid()) {
                Optional<JsonNode> jsonNodeOptional = edgeLabel.toNotifyJson();
                if (jsonNodeOptional.isPresent()) {
                    foundInEdgeLabels = true;
                    inEdgeLabelsArrayNode.add(jsonNodeOptional.get());
                }
            }
        }
        if (foundInEdgeLabels) {
            vertexLabelNode.set("inEdgeLabels", inEdgeLabelsArrayNode);
        }
        return Optional.of(vertexLabelNode);
    }

    /**
     * @param vertexLabelJson The VertexLabel's notification json
     * @param fire            should we fire topology events
     */
    void fromNotifyJsonOutEdge(JsonNode vertexLabelJson, boolean fire) {
        super.fromPropertyNotifyJson(vertexLabelJson, fire);
        for (String s : Arrays.asList("uncommittedOutEdgeLabels", "outEdgeLabels")) {
            ArrayNode uncommittedOutEdgeLabels = (ArrayNode) vertexLabelJson.get(s);
            if (uncommittedOutEdgeLabels != null) {
                for (JsonNode uncommittedOutEdgeLabel : uncommittedOutEdgeLabels) {
                    String schemaName = uncommittedOutEdgeLabel.get("schema").asText();
                    Preconditions.checkState(schemaName.equals(getSchema().getName()), "out edges must be for the same schema that the edge specifies");
                    String edgeLabelName = uncommittedOutEdgeLabel.get("label").asText();
                    Optional<EdgeLabel> edgeLabelOptional = this.schema.getEdgeLabel(edgeLabelName);
                    EdgeLabel edgeLabel;
                    if (edgeLabelOptional.isEmpty()) {
                        PartitionType partitionType = PartitionType.valueOf(uncommittedOutEdgeLabel.get("partitionType").asText());
                        if (partitionType.isNone()) {
                            edgeLabel = new EdgeLabel(this.getSchema().getTopology(), edgeLabelName);
                        } else {
                            String partitionExpression = uncommittedOutEdgeLabel.get("partitionExpression").asText();
                            edgeLabel = new EdgeLabel(this.getSchema().getTopology(), edgeLabelName, partitionType, partitionExpression);
                        }
                    } else {
                        edgeLabel = edgeLabelOptional.get();
                    }
                    edgeLabel.addToOutVertexLabel(this);
                    this.outEdgeLabels.put(schemaName + "." + edgeLabel.getLabel(), edgeLabel);
                    // fire if we didn't create the edge label
                    edgeLabel.fromPropertyNotifyJson(uncommittedOutEdgeLabel, edgeLabelOptional.isPresent());
                    //Babysit the cache
                    this.getSchema().getTopology().addToAllTables(getSchema().getName() + "." + EDGE_PREFIX + edgeLabel.getLabel(), edgeLabel.getPropertyTypeMap());
                    this.getSchema().addToAllEdgeCache(edgeLabel);
                    this.getSchema().getTopology().addOutForeignKeysToVertexLabel(this, edgeLabel);
                    ForeignKey foreignKey;
                    if (this.hasIDPrimaryKey()) {
                        foreignKey = ForeignKey.of(this.getFullName() + Topology.OUT_VERTEX_COLUMN_END);
                    } else {
                        foreignKey = new ForeignKey();
                        for (String identifier : this.getIdentifiers()) {
                            if (!isDistributed() || !getDistributionPropertyColumn().getName().equals(identifier)) {
                                //The distribution column needs to be ignored as its a regular property and not a __I or __O property
                                foreignKey.add(this.getFullName(), identifier, Topology.OUT_VERTEX_COLUMN_END);
                            }
                        }
                    }
                    this.getSchema().getTopology().addToEdgeForeignKeyCache(
                            this.getSchema().getName() + "." + EDGE_PREFIX + edgeLabel.getLabel(),
                            foreignKey
                    );
                    // fire only applies to top level, fire for new edges
                    if (edgeLabelOptional.isEmpty()) {
                        this.getSchema().getTopology().fire(edgeLabel, null, TopologyChangeAction.CREATE);
                    }
                }
            }
        }
        ArrayNode uncommittedRemoveOutEdgeLabels = (ArrayNode) vertexLabelJson.get("uncommittedRemovedOutEdgeLabels");
        if (uncommittedRemoveOutEdgeLabels != null) {
            for (JsonNode n : uncommittedRemoveOutEdgeLabels) {
                EdgeLabel lbl = this.outEdgeLabels.remove(n.get("label").asText());
                if (lbl != null) {
                    EdgeRemoveType ert = EdgeRemoveType.valueOf(n.get("type").asText());
                    ForeignKey foreignKey;
                    if (this.hasIDPrimaryKey()) {
                        foreignKey = ForeignKey.of(this.getFullName() + Topology.OUT_VERTEX_COLUMN_END);
                    } else {
                        foreignKey = new ForeignKey();
                        for (String identifier : this.getIdentifiers()) {
                            if (!isDistributed() || !getDistributionPropertyColumn().getName().equals(identifier)) {
                                //The distribution column needs to be ignored as it's a regular property and not a __I or __O property
                                foreignKey.add(this.getFullName(), identifier, Topology.OUT_VERTEX_COLUMN_END);
                            }
                        }
                    }
                    this.getSchema().getTopology().removeFromEdgeForeignKeyCache(
                            lbl.getSchema().getName() + "." + EDGE_PREFIX + lbl.getLabel(),
                            foreignKey
                    );
                    this.getSchema().getTopology().removeOutForeignKeysFromVertexLabel(this, lbl);
                    lbl.outVertexLabels.remove(this);

                    switch (ert) {
                        case EDGE_LABEL:
                            this.getSchema().getTopology().fire(lbl, lbl, TopologyChangeAction.DELETE);
                            break;
                        case EDGE_ROLE:
                            EdgeRole topologyInf = new EdgeRole(this, lbl, Direction.OUT, true);
                            this.getSchema().getTopology().fire(topologyInf, topologyInf, TopologyChangeAction.DELETE);
                            break;
                        default:
                            break;
                    }

                }
            }
        }
    }

    void fromNotifyJsonInEdge(JsonNode vertexLabelJson) {
        for (String s : Arrays.asList("uncommittedInEdgeLabels", "inEdgeLabels")) {
            ArrayNode uncommittedInEdgeLabels = (ArrayNode) vertexLabelJson.get(s);
            if (uncommittedInEdgeLabels != null) {
                for (JsonNode uncommittedInEdgeLabel : uncommittedInEdgeLabels) {
                    String schemaName = uncommittedInEdgeLabel.get("schema").asText();
                    String edgeLabelName = uncommittedInEdgeLabel.get("label").asText();
                    Optional<Schema> schemaOptional = getSchema().getTopology().getSchema(schemaName);
                    Preconditions.checkState(schemaOptional.isPresent(), "Schema %s must be present", schemaName);
                    Optional<EdgeLabel> edgeLabelOptional = schemaOptional.get().getEdgeLabel(edgeLabelName);
                    //The edgeLabel could have been deleted
                    if (edgeLabelOptional.isPresent()) {
                        EdgeLabel edgeLabel = edgeLabelOptional.get();
                        edgeLabel.addToInVertexLabel(this);
                        this.inEdgeLabels.put(schemaName + "." + edgeLabel.getLabel(), edgeLabel);
                        edgeLabel.fromPropertyNotifyJson(uncommittedInEdgeLabel, false);
                        this.getSchema().getTopology().addInForeignKeysToVertexLabel(this, edgeLabel);
                        ForeignKey foreignKey;
                        if (this.hasIDPrimaryKey()) {
                            foreignKey = ForeignKey.of(this.getFullName() + Topology.IN_VERTEX_COLUMN_END);
                        } else {
                            foreignKey = new ForeignKey();
                            for (String identifier : this.getIdentifiers()) {
                                if (!isDistributed() || !getDistributionPropertyColumn().getName().equals(identifier)) {
                                    //The distribution column needs to be ignored as its a regular property and not a __I or __O property
                                    foreignKey.add(this.getFullName(), identifier, Topology.IN_VERTEX_COLUMN_END);
                                }
                            }
                        }
                        this.getSchema().getTopology().addToEdgeForeignKeyCache(
                                edgeLabel.getSchema().getName() + "." + EDGE_PREFIX + edgeLabel.getLabel(),
                                foreignKey
                        );

                    }
                }
            }
        }
        ArrayNode uncommittedRemoveInEdgeLabels = (ArrayNode) vertexLabelJson.get("uncommittedRemovedInEdgeLabels");
        if (uncommittedRemoveInEdgeLabels != null) {
            for (JsonNode n : uncommittedRemoveInEdgeLabels) {
                EdgeLabel lbl = this.inEdgeLabels.remove(n.get("label").asText());
                if (lbl != null) {
                    EdgeRemoveType ert = EdgeRemoveType.valueOf(n.get("type").asText());
                    if (lbl.isValid()) {
                        ForeignKey foreignKey;
                        if (this.hasIDPrimaryKey()) {
                            foreignKey = ForeignKey.of(this.getFullName() + Topology.IN_VERTEX_COLUMN_END);
                        } else {
                            foreignKey = new ForeignKey();
                            for (String identifier : this.getIdentifiers()) {
                                foreignKey.add(this.getFullName(), identifier, Topology.IN_VERTEX_COLUMN_END);
                            }
                        }
                        this.getSchema().getTopology().removeFromEdgeForeignKeyCache(
                                lbl.getSchema().getName() + "." + EDGE_PREFIX + lbl.getLabel(),
                                foreignKey
                        );
                        this.getSchema().getTopology().removeInForeignKeysFromVertexLabel(this, lbl);
                    }
                    lbl.inVertexLabels.remove(this);

                    switch (ert) {
                        case EDGE_LABEL:
                            this.getSchema().getTopology().fire(lbl, lbl, TopologyChangeAction.DELETE);
                            break;
                        case EDGE_ROLE:
                            EdgeRole topologyInf = new EdgeRole(this, lbl, Direction.IN, true);
                            this.getSchema().getTopology().fire(topologyInf, topologyInf, TopologyChangeAction.DELETE);
                            break;
                    }

                }
            }
        }
    }

    @Override
    public int hashCode() {
        return (this.schema.getName() + this.getLabel()).hashCode();
    }

    @Override
    public boolean equals(Object other) {
        if (!super.equals(other)) {
            return false;
        }
        if (!(other instanceof VertexLabel)) {
            return false;
        }
        VertexLabel otherVertexLabel = (VertexLabel) other;
        return this.schema.equals(otherVertexLabel.getSchema()) && super.equals(otherVertexLabel);
    }

    boolean deepEquals(VertexLabel other) {
        Preconditions.checkState(this.equals(other), "deepEquals is only called after equals has succeeded");
        if (!this.outEdgeLabels.equals(other.outEdgeLabels)) {
            return false;
        } else {
            for (EdgeLabel outEdgeLabel : this.outEdgeLabels.values()) {
                for (EdgeLabel otherOutEdgeLabel : other.outEdgeLabels.values()) {
                    if (outEdgeLabel.equals(otherOutEdgeLabel)) {
                        if (!outEdgeLabel.deepEquals(otherOutEdgeLabel)) {
                            return false;
                        }
                    }
                }
            }
            return true;
        }
    }

    @Override
    public List<Topology.TopologyValidationError> validateTopology(DatabaseMetaData metadata) throws SQLException {
        List<Topology.TopologyValidationError> validationErrors = new ArrayList<>();
        for (PropertyColumn propertyColumn : getProperties().values()) {
            List<Triple<String, Integer, String>> columns = this.sqlgGraph.getSqlDialect().getTableColumns(metadata, null, this.getSchema().getName(), "V_" + this.getLabel(), propertyColumn.getName());
            if (columns.isEmpty()) {
                validationErrors.add(new Topology.TopologyValidationError(propertyColumn));
            }
//            try (ResultSet propertyRs = metadata.getColumns(null, this.getSchema().getName(), "V_" + this.getLabel(), propertyColumn.getName())) {
//                if (!propertyRs.next()) {
//                    validationErrors.add(new Topology.TopologyValidationError(propertyColumn));
//                }
//            }
        }
        for (Index index : getIndexes().values()) {
            validationErrors.addAll(index.validateTopology(metadata));
        }
        return validationErrors;
    }

    @Override
    public String getPrefix() {
        return VERTEX_PREFIX;
    }

    Pair<Set<SchemaTable>, Set<SchemaTable>> getUncommittedSchemaTableForeignKeys() {
        Pair<Set<SchemaTable>, Set<SchemaTable>> result = Pair.of(new HashSet<>(), new HashSet<>());
        for (Map.Entry<String, EdgeLabel> uncommittedEdgeLabelEntry : this.uncommittedOutEdgeLabels.entrySet()) {
            String key = uncommittedEdgeLabelEntry.getKey();
            EdgeLabel edgeLabel = uncommittedEdgeLabelEntry.getValue();
            if (!this.uncommittedRemovedOutEdgeLabels.containsKey(key)) {
                result.getRight().add(SchemaTable.of(this.getSchema().getName(), EDGE_PREFIX + edgeLabel.getLabel()));
            }
        }
        for (Map.Entry<String, EdgeLabel> uncommittedEdgeLabelEntry : this.uncommittedInEdgeLabels.entrySet()) {
            String key = uncommittedEdgeLabelEntry.getKey();
            EdgeLabel edgeLabel = uncommittedEdgeLabelEntry.getValue();
            if (!this.uncommittedRemovedInEdgeLabels.containsKey(key)) {
                result.getLeft().add(SchemaTable.of(edgeLabel.getSchema().getName(), EDGE_PREFIX + edgeLabel.getLabel()));
            }
        }
        return result;
    }

    Pair<Set<SchemaTable>, Set<SchemaTable>> getUncommittedRemovedSchemaTableForeignKeys() {
        Pair<Set<SchemaTable>, Set<SchemaTable>> result = Pair.of(new HashSet<>(), new HashSet<>());
        for (Map.Entry<String, Pair<EdgeLabel, EdgeRemoveType>> uncommittedEdgeLabelEntry : this.uncommittedRemovedOutEdgeLabels.entrySet()) {
            Pair<EdgeLabel, EdgeRemoveType> edgeLabelPair = uncommittedEdgeLabelEntry.getValue();
            EdgeLabel edgeLabel = edgeLabelPair.getKey();
            result.getRight().add(SchemaTable.of(this.getSchema().getName(), EDGE_PREFIX + edgeLabel.getLabel()));
        }
        for (Map.Entry<String, Pair<EdgeLabel, EdgeRemoveType>> uncommittedEdgeLabelEntry : this.uncommittedRemovedInEdgeLabels.entrySet()) {
            Pair<EdgeLabel, EdgeRemoveType> edgeLabelPair = uncommittedEdgeLabelEntry.getValue();
            EdgeLabel edgeLabel = edgeLabelPair.getKey();
            result.getLeft().add(SchemaTable.of(edgeLabel.getSchema().getName(), EDGE_PREFIX + edgeLabel.getLabel()));
        }
        return result;
    }

    @Override
    void removeProperty(PropertyColumn propertyColumn, boolean preserveData) {
        this.getSchema().getTopology().startSchemaChange();
        if (!this.uncommittedRemovedProperties.contains(propertyColumn.getName())) {
            this.uncommittedRemovedProperties.add(propertyColumn.getName());
            for (Index index : getIndexes().values()) {
                for (PropertyColumn property : index.getProperties()) {
                    if (property.getName().equals(propertyColumn.getName())) {
                        index.remove(preserveData);
                        break;
                    }
                }
            }
            TopologyManager.removeVertexColumn(this.sqlgGraph, this.schema.getName(), VERTEX_PREFIX + getLabel(), propertyColumn.getName());
            if (!preserveData) {
                removeColumn(this.schema.getName(), VERTEX_PREFIX + getLabel(), propertyColumn.getName());
            }
            this.getSchema().getTopology().fire(propertyColumn, propertyColumn, TopologyChangeAction.DELETE);
        }
    }

    @Override
    void renameProperty(String name, PropertyColumn propertyColumn) {
        this.getSchema().getTopology().startSchemaChange();
        String oldName = propertyColumn.getName();
        Pair<String, String> namePair = Pair.of(oldName, name);
        if (!this.uncommittedRemovedProperties.contains(name)) {
            this.uncommittedRemovedProperties.add(oldName);
            PropertyColumn copy = new PropertyColumn(this, name, propertyColumn.getPropertyType());
            this.uncommittedProperties.put(name, copy);
            TopologyManager.renameVertexLabelPropertyColumn(this.sqlgGraph, this.schema.getName(), VERTEX_PREFIX + getLabel(), oldName, name);
            renameColumn(this.schema.getName(), VERTEX_PREFIX + getLabel(), oldName, name);
            if (this.getIdentifiers().contains(oldName)) {
                Preconditions.checkState(!this.renamedIdentifiers.contains(namePair), "BUG! renamedIdentifiers may not yet contain '%s'", oldName);
                this.renamedIdentifiers.add(namePair);

                Map<String, EdgeLabel> outEdgeLabels = getOutEdgeLabels();
                for (String outEdgeLabel : outEdgeLabels.keySet()) {
                    EdgeLabel edgeLabel = outEdgeLabels.get(outEdgeLabel);
                    edgeLabel.renameOutForeignKeyIdentifier(oldName, name, this);
                }
                Map<String, EdgeLabel> inEdgeLabels = getInEdgeLabels();
                for (String inEdgeLabel : inEdgeLabels.keySet()) {
                    EdgeLabel edgeLabel = inEdgeLabels.get(inEdgeLabel);
                    edgeLabel.renameInForeignKeyIdentifier(oldName, name, this);
                }

            }
            this.getSchema().getTopology().fire(copy, propertyColumn, TopologyChangeAction.UPDATE);
        }
    }

    void removeOutEdge(EdgeLabel lbl) {
        this.uncommittedRemovedOutEdgeLabels.put(lbl.getFullName(), Pair.of(lbl, EdgeRemoveType.EDGE_LABEL));
    }

    void removeInEdge(EdgeLabel lbl) {
        this.uncommittedRemovedInEdgeLabels.put(lbl.getFullName(), Pair.of(lbl, EdgeRemoveType.EDGE_LABEL));
    }

    /**
     * remove a given edge role
     *
     * @param er           the edge role
     * @param preserveData should we keep the SQL data
     */
    void removeEdgeRole(EdgeRole er, boolean dropEdges, boolean preserveData) {
        if (er.getVertexLabel() != this) {
            throw new IllegalStateException("Trying to remove a EdgeRole from a non owner VertexLabel");
        }
        Collection<VertexLabel> ers;
        switch (er.getDirection()) {
            // we don't support both
            case BOTH:
                throw new IllegalStateException("BOTH is not a supported direction");
            case IN:
                ers = er.getEdgeLabel().getInVertexLabels();
                break;
            case OUT:
                ers = er.getEdgeLabel().getOutVertexLabels();
                break;
            default:
                throw new IllegalStateException("Unknown direction!");
        }
        if (!ers.contains(this)) {
            throw new IllegalStateException("Trying to remove a EdgeRole from a non owner VertexLabel");
        }
        // the edge had only this vertex on that direction, remove the edge
        if (ers.size() == 1) {
            er.getEdgeLabel().remove(preserveData);
        } else {
            getSchema().getTopology().startSchemaChange();
            EdgeLabel edgeLabel = er.getEdgeLabel();
            switch (er.getDirection()) {
                // we don't support both
                case BOTH:
                    throw new IllegalStateException("BOTH is not a supported direction");
                case IN:
                    er.getEdgeLabel().removeInVertexLabel(this, dropEdges, preserveData);
                    this.uncommittedRemovedInEdgeLabels.put(edgeLabel.getFullName(), Pair.of(edgeLabel, EdgeRemoveType.EDGE_ROLE));
                    break;
                case OUT:
                    er.getEdgeLabel().removeOutVertexLabel(this, dropEdges, preserveData);
                    this.uncommittedRemovedOutEdgeLabels.put(edgeLabel.getFullName(), Pair.of(edgeLabel, EdgeRemoveType.EDGE_ROLE));
                    break;
            }

            this.getSchema().getTopology().fire(er, er, TopologyChangeAction.DELETE);
        }
    }

    @Override
    public void remove(boolean preserveData) {
        this.getSchema().removeVertexLabel(this, preserveData);
    }

    /**
     * delete the table
     */
    void delete() {
        String schema = getSchema().getName();
        String tableName = VERTEX_PREFIX + getLabel();

        SqlDialect sqlDialect = this.sqlgGraph.getSqlDialect();
        sqlDialect.assertTableName(tableName);
        StringBuilder sql = new StringBuilder("DROP TABLE IF EXISTS ");
        sql.append(sqlDialect.maybeWrapInQoutes(schema));
        sql.append(".");
        sql.append(sqlDialect.maybeWrapInQoutes(tableName));
        if (sqlDialect.supportsCascade()) {
            sql.append(" CASCADE");
        }
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug(sql.toString());
        }
        if (sqlDialect.needsSemicolon()) {
            sql.append(";");
        }
        Connection conn = sqlgGraph.tx().getConnection();
        try (Statement stmt = conn.createStatement()) {
            stmt.execute(sql.toString());
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    VertexLabel readOnlyCopy(Schema schema) {
        VertexLabel copy = new VertexLabel(schema, this.label, true);
        for (String property : this.properties.keySet()) {
            copy.properties.put(property, this.properties.get(property).readOnlyCopy(copy));
        }
        copy.identifiers.addAll(this.identifiers);
        return copy;
    }

    @Override
    public void rename(String label) {
        Objects.requireNonNull(label, "Given label must not be null");
        Preconditions.checkArgument(!label.startsWith(VERTEX_PREFIX), "label may not be prefixed with \"%s\"", VERTEX_PREFIX);
        Preconditions.checkState(!this.isForeignAbstractLabel, "'%s' is a read only foreign table!", label);
        this.getSchema().getTopology().startSchemaChange();
        VertexLabel renamedVertexLabel = this.getSchema().renameVertexLabel(this, label);
        Map<String, EdgeLabel> outEdgeLabels = getOutEdgeLabels();
        for (String outEdgeLabel : outEdgeLabels.keySet()) {
            EdgeLabel edgeLabel = outEdgeLabels.get(outEdgeLabel);
            edgeLabel.renameOutVertexLabel(renamedVertexLabel, this);
        }
        Map<String, EdgeLabel> inEdgeLabels = getInEdgeLabels();
        for (String inEdgeLabel : inEdgeLabels.keySet()) {
            EdgeLabel edgeLabel = inEdgeLabels.get(inEdgeLabel);
            edgeLabel.renameInVertexLabel(renamedVertexLabel, this);
        }
    }
}


text:
Cruise Newsletters Archive
To return to the main Archives page, please click here.
To subscribe to our weekly newsletter, absolutely free of charge, please click here.
Family Reunion Cruise in Costa Rica
Several times over the years, three generations of my family have gathered on a cruise ship, as we have all determined that a cruise is simply the best venue there is for our family reunions. It seems to me that I see more and more extended families when I cruise.
In 2000, I cruised Costa Rica and Panama on the 100-passenger Temptress Explorer (now the Pacific Explorer), and a single family comprised nearly a third of the passengers on the boat. The patriarch was a 70-year-old physician who had recently retired, accompanied by his wife, sons, daughters, their spouses and mostly teenage grandchildren.
Our cruise was billed as an adventure cruise, and geared toward active and physically fit travelers in their 30s, 40s and 50s. There were no actual port calls during the week-long voyage. We sailed at night and dropped anchor each day alongside an uninhabited beach, rain forest or island. Some days we boarded inflatable Zodiac rafts for the trip ashore, and some days we just jumped off the platform at the back of the ship and swam to shore. The ship offered snorkeling, scuba, kayaking, and water skiing, plus rain forest and mountain hikes to check out the amazing flora and fauna, which included monkeys, parrots, 3-toed sloths and anteaters.
One gray, drizzly morning we set off for a mountain hike that had been described on board as being very physically challenging, and I was surprised to see the physician climb into the Zodiac for the ride to the base of the trail. Perhaps I should not have been surprised, because by that time I knew the physician had tackled the most strenuous offering at every stop, and he already sported stitches in his arm from a tumble down a mountainside on an earlier hike. But here he was again, in fine spirits and looking for a new adventure.
The hike lived up to its billing. We slogged through 6 inches of mud in some spots, climbing up and down hillsides and fording streams at broad shallows. We stopped frequently to allow the physician to catch up when he dropped behind the pace set by our guide, but he never gave up or turned back.
After several miles, our path gradually turned back toward the coast, and I became aware of the sound of rushing water. If you have ever kayaked a river you know the sound I am talking about -- the low, distant roar of white water. We rounded a bend in the path and could see the point of our final crossing, a fairly treacherous stretch of river with slick rocks jutting out of rushing water that was too churned up to reveal its depth. One by one, we waded in, up to our waists.
I remember seeing the physician pacing the bank for a good place to cross, and I wondered again what had possessed him to sign up for this particular hike with its "most strenuous" rating. I remember watching him carefully plant each foot in the water, searching for a level spot among the slippery rocks. Concentrating on my own crossing, I did not see him step into a hole and vanish from sight, but I heard and saw the uproar as teenage grandchildren piled into that deep spot from every direction.
Soaked head to toe and bleeding from the shins, the physician was pulled back to the bank. Our guide carried a first aid kit and attended to his cuts, but under that dense canopy of branches, with the rain falling, it was cool and he was shivering. And we still needed to cross that river.
Then ingenuity struck, and the physician's kith and kin stretched out in a line from one bank to the other, and the founder of the feast was helped from one station to another, until he was again on solid ground.
By that evening, the bandaged physician had become somewhat of a celebrity on our small boat, and the un-related passengers were split as to whether he was a fearless adventurer or, in fact, quite mad. He had assembled his entire family in the jungles of Costa Rica for the ultimate family reunion, and had no doubt created lifelong memories for every participant. He seemed determined to demonstrate that he still had it, and I had to admire him for that.
There's a cruise ship out there that's perfect for any type of family reunion, and our group department (800-514-9986) can make all the arrangements. For those needing 8 or more cabins, it's best to plan at least 6 months in advance to get a low group rate and ensure plenty of availability.
Even if you end up on an adventure cruise, you won't have to test your physical limits, but you can if you want to. I'll bring the first aid kit.
Alan Fox
Vacations To Go
To email this newsletter to a friend or friends, click here. To see a copy of our current newsletter, click here. To subscribe to our weekly newsletter, absolutely free of charge, please click here.
Email this Newsletter
Share using your email or copy and send page link below.
Click to Email Newsletter
http://www.VacationsToGo.com/newsletter_archive.cfm?archive=family_reunion_cruise

redpajama_set_name: RedPajamaCommonCrawl


Set 900 metres from Palermo Cathedral, La Cupola offers stylish self-catering accommodation with air conditioning. Palermo Harbour can be reached on foot in 15 minutes. Featuring exposed brick walls, the one-bedroom apartment at La Cupola includes a modern kitchen, a living area with flat-screen TV, and a dining area. The bathroom has a hairdryer. The Politeama Theatre is 750 metres away. Isola delle Femmine is a 25-minute drive away. Mondello Beach is 10 km from the property.


text:
Пло́щадь Револю́ции — название площадей в различных населённых пунктах мира, а также связанных станций метро.

Куба
 Площадь Революции — площадь в Гаване.

Никарагуа
 Площадь Революции — площадь в Манагуа.

Россия
 Площадь Революции — площадь в Алапаевске Свердловской области.
 Площадь Революции — площадь в Брянске.
 Площадь Революции — площадь во Владикавказе.
 Площадь Революции — площадь в Вологде.
 Площадь Революции — площадь в Ельце Липецкой области.
 Площадь Революции — площадь в Зарайске Московской области.
 Площадь Революции — площадь в Иваново.
 Площадь Революции — площадь в Истре Московской области.
 Площадь Революции — площадь в Кирове.
 Площадь Революции — площадь в Краснодаре.
 Площадь Революции — площадь в Красноярске.
 Площадь Революции — площадь в Липецке.
 Площадь Революции — площадь в Лосино-Петровском Московской области.
 Площадь Революции — площадь в Миассе Челябинской области.
 Площадь Революции — площадь в Москве.
 Площадь Революции — площадь в Муроме Владимирской области.
 Площадь Революции — площадь в Нижнем Новгороде.
 Площадь Революции — площадь в Ногинске Московской области.
 Площадь Революции — площадь в Павловском Посаде Московской области.
 Площадь Революции — площадь в Ржеве Тверской области.
 Площадь Революции — площадь в Самаре.
 Площадь Революции — площадь в Серпухове Московской области.
 Площадь Революции — площадь в Сызрани Самарской области.
 Площадь Революции — площадь в Улан-Удэ.
 Площадь Революции — площадь в Челябинске.
 Площадь Революции — площадь в Череповце Вологодской области.
 Площадь Революции — площадь в Чите.
 Площадь Революции — площадь в Чухломе Костромской области.

Прежние названия
 Площадь Революции — прежнее название Якорной площади в Кронштадте.
 Площадь Революции — прежнее название Троицкой площади в Новочеркасске.
 Площадь Революции — прежнее название Торговой площади в Плёсе.
 Площадь Революции — прежнее название Троицкой площади в Санкт-Петербурге.
 Площадь Революции — прежнее название Театральной площади в Саратове.
 Площадь Революции — прежнее название Соборной площади в Старой Руссе.
 Площадь Революции — прежнее название Соборной площади в Твери.
 Площадь Революции — название Новособорной площади в Томске с 20 мая 1920 года до 26 мая 1997 года.
 Площадь Революции — прежнее название Георгиевской площади в Юрьевце.

Румыния
 Площадь Революции — площадь в Бухаресте.

Словения
 Площадь Революции — площадь в Мариборе.

Украина
 Площадь Революции — площадь в Горловке Донецкой области.
 Площадь Революции — площадь в Луганске.
 Площадь Революции — прежнее название Соборной площади в Мелитополе Запорожской области.

Станции метро

См. также
 Площадь Борцов Революции.
 Площадь Двух Революций.
 Площадь Жертв Революции.
 Площадь Октябрьской Революции — площадь в Краснодаре.
 Площадь Восстания.
 Улица Революции.
 Проспект Революции.
 Переулок Революции.
 Шоссе Революции
 Площадь Согласия в Париже в конце XVIII века называлась площадью Революции.

redpajama_set_name: RedPajamaWikipedia


text:
Eltz ist der Name eines alten, ursprünglich hochfreien Adelsgeschlechts aus dem Rheinland. Die Familie, deren Zweige zum Teil bis heute bestehen, gehört zum moselländischen Uradel. Sie ist nicht zu verwechseln mit einem gleichnamigen niedersächsischen Geschlecht.

Geschichte

Herkunft
In älterer Literatur wird erwähnt, dass bereits im Jahre 690 ein Ritter Eberhardus zu Eltz unter den Patriziern der Stadt Trier erscheinen soll. Der Genealoge Johann Maximilian von Humbracht beginnt die ordentliche Stammreihe der Familie mit Georg um das Jahr 938.

Nach dem Genealogischen Handbuch des Adels erscheint die Familie erstmals mit Rudolfus, der von 1150 bis 1157 in Urkunden genannt wird. Er war der erste Familienangehörige, der den Namen der Stammburg Eltz angenommen hat. Rudolph war ein treuer Gefolgsmann des Stauferkaisers Friedrich I. Barbarossa und erhielt von ihm als Dank für seine Heeresdienste ein Stück Land zu Lehen. Die ununterbrochene Stammreihe beginnt mit Petrus nobilis vir, dominus de Eltze, der zwischen 1210 und 1257 urkundlich erscheint. Er war wahrscheinlich ein Sohn des Elias, der am 27. März 1194 als Burgsasse zu Eltz in einer Urkunde genannt wird.

Die ursprünglich edelfreien Herren von Eltz wurden Ministeriale des Heiligen Römischen Reiches. Als Burgmannen und Ganerben saßen sie auf der Burg Eltz bei Wierschem nahe der Stadt Münstermaifeld. Nach der Eltzer Fehde (1331 bis 1336) wurde 1356 der Reichslehenverband endgültig aufgelöst und die Burg ein Lehen des Reichsstifts Trier. Aus den Reichsvasallen von Eltz wurden Lehnsleute des Erzbischofs und Kurfürsten von Trier.

Grablege in Münstermaifeld
Die Eltzer Herren pflegten über Jahrhunderte eine enge Verbindung zur nahe ihrer Stammburg gelegenen Stadt Münstermaifeld. Sie waren im ganzen Spätmittelalter in der Verwaltung der Stadt tätig. In der ehemaligen Stiftskirche Münstermaifeld befinden sich Eltzer Gräber. Besonders kunstvoll sind die Epitaphien des Ehepaares Cuno von Eltz und Ella von Esch, zwei Reliefplatten aus Basalt, weiterhin das Marmorgrab des Nikolaus von Eltz und seiner Frau Maria von Hoort sowie ein Marmordenkmal für deren Sohn Johann Wilhelm Antonius Bertramus Herr zu Eltz, Domherr zu Trier. Söhne derer von Eltz waren in allen Jahrhunderten Kanoniker im Stift Münstermaifeld. Durch einen viele Jahrzehnte währenden Streit mit dem Papst wurde Lothar von Eltz, 1267 vom Kapitel zu "Monster Meynfelt" zum rechtmäßigen "Praepositus" gewählt, bekannt. Einer der tatkräftigsten Stiftspröpste in Münstermaifeld war Elias von Eltz (1331–1347).

Eltzer Persönlichkeiten im Mittelalter
Bereits während des 13. Jahrhunderts teilten die Brüder Elias, Wilhelm und Theoderich den Stamm in drei Linien, die sich im Laufe der Zeit in weitere Äste und Zweige aufspalteten. Auch die Burg mit den dazugehörigen Gütern wurde mehrmals aufgeteilt. Noch heute lassen sich an der Burg Eltz die Teilbauten der Linien zu Kempenich, Rübenach und Rodendorf in der Form selbständiger Wohntürme erkennen.

Zahlreiche Angehörige der Familie waren schon früh für den Deutschen Orden in Pommern und im Baltikum tätig. Arnold von Eltz († 1329 oder 1330) war zunächst Domherr zu Trier und wurde 1324 von Papst Johannes XXII. als Bischof von Cammin eingesetzt. Robin von Eltz war von 1367 bis 1392 Heermeister des Deutschen Ordens in Livland und Georg von Eltz starb 1532 als Komtur des Deutschen Ordens. Er wurde oft im Auftrag des Ordens mit diplomatischen Missionen betraut, so unter anderem in Deutschland, Livland, Polen, Spanien und Rom.

1331 schlossen sich die Eltzer mit einigen anderen faktischen Reichsministerialen, den Besitzern der Burgen Waldeck, Schöneck und Ehrenburg, zu einem Bund zusammen. In der Eltzer Fehde kämpften sie gegen die Territorialpolitik des Trierer Kurfürsten Balduin von Luxemburg, der sich auf die alten Lehnsrechte Kurtriers berief und die vermeintlichen Reichsritter wieder dem Trierer Amts- und Dienstrecht unterwerfen wollte. Fünf Jahre später verpflichteten sich die Streiter in der Eltzer Sühne zum Frieden und mussten die Oberherrschaft Kurtriers anerkennen.

Werner Brender von Eltz übertrug im Jahre 1311 seinem Sohn Peter die Vogtei zu Rübenach. Bereits ein Jahr später konnten die zur Vogtei Rübenach gehörenden Güter vom Grafen Ruprecht von Virneburg erworben werden. 1563 wurde die Linie Eltz-Rübenach erneut von den Herzögen von Luxemburg mit Rübenach und Bisholder belehnt. 1401 erhielt Dietrich, Herr zu Eltz, vom römischen König Ruprecht, als Pfalzgraf bei Rhein, die Güter von Winand Boos von Waldeck, mit Anteilen an der Ganerbenburg Waldeck. Dieser Erbteil war nach dem Tod Winands an den Pfalzgrafen zurückgefallen, der sie als Lehen an die Eltzer weitergab.

1476 gehörte ein Zweig der Eltzer zu den Erben der Elsa von Brohl auf Burg Brohl, der Letzten ihres Geschlechts, allerdings in Erbengemeinschaft mit den Familien von Winneburg und von Braunsberg, was zu fast 100-jährigen Auseinandersetzungen führte. Im Jahre 1526 erbte ein Sohn von Ulrich von Eltz, Mitherr zu Burg Brohl, Philipp von Eltz, von seiner Mutter Elisabeth von Pyrmont und deren Brüdern die umfangreichen Besitzungen des Hauses Pyrmont und die Herrschaft Ehrenberg.

1486 gingen durch einen erneuten Erbgang Güter und Ländereien der Koblenzer Adelsfamilie von Bachem an die Herren von Eltz. Dazu zählte auch ein Hof in Boppard; der ehemalige Hof der Herren von Bachem wurde urkundlich 1496 erstmals als Eltzer Hof bezeichnet. Die von Eltz gehörten damit zum Ritterrat des Bopparder Stadtrates. Im Jahre 1495 führte Johann von Eltz der Alte eine Delegation der Stadt zum römisch-deutschen König Maximilian I. Am 27. Juni 1495 stellte Maximilian ihnen das Privileg aus, die Stadtbefestigung in Eigenverantwortung zu übernehmen. Nach Protest des Trierer Kurfürsten Johann II. von Baden als Landesherrn widerrief Maximilian aber dieses Privileg. Daraufhin versuchte die Stadt Boppard unter Einwirkung von Johann von Eltz, an dem Privileg festzuhalten. Der Kurfürst erklärte am 7. Juni 1497 der Stadt die Fehde. Nach der Belagerung durch den Kurfürsten kapitulierte Boppard am 30. Juni 1497. Jedoch konnte zwischen Johann von Eltz und dem Kurfürsten kein Friede geschlossen werden, da neben den Bopparder Angelegenheiten auch weitere Besitzstreitigkeiten eine Rolle spielten. Versuche, den Streit mit Hilfe von Schiedsleuten beizulegen, scheiterten. Auch der Reichstag zu Worms im Jahr 1497, zu dem er von der Stadt Boppard abgeordnet wurde, brachte keine Einigung. Am Dreikönigstag des Jahres 1501 kam Johann von Eltz zu Schiff mit 200–250 Landsknechten nach Boppard. Mit Einvernehmen der Bopparder Ritterschaft ließ er den Hof der Beyer von Boppard, die stets auf Seiten des Kurfürsten standen, und die kurfürstliche Burg plündern. Noch am gleichen Tag schrieb Johann von Eltz an den Trierer Kurfürsten und legte die Gründe für sein Handeln dar, begab sich dann in den Dienst des Kurfürsten Philipp von der Pfalz und wurde Amtmann in Kaub. Im Jahr 1517 starb Johann von Eltz.

In der frühen Neuzeit

Johann Jakob von Eltz aus der Kempenicher Linie war von 1567 bis zu seinem Tode 1581 Kurfürst und Erzbischof von Trier. Er führte in der Stadt Trier die Gegenreformation durch, sowie kirchliche Reformmaßnahmen gemäß dem Konzil von Trient. Am 8. Juni 1580 verlieh er als Kurfürst von Trier seinen Neffen, den Brüdern Anton, kurfürstlich trierischer Rat, Marschall und Amtmann, und Hans Reichard sowie deren Vetter Hans Anton das Erbmarschallsamt des Kurfürstentums Trier als Lehen. Das Amt war nach dem Tod von Johann, dem letzten des Geschlechts derer von Helfenstein, an Kurtierer zurückgefallen.

Die Enkel von Georg, dem Bruder des Kurfürsten, waren die Stifter der Linien zu Eltz-Oetingen und Eltz-Kempenich (von Kurtrier als Pfand erhalten ab 1663). Die Vettern von Georg begründeten wiederum zwei Linien, Johann Friedrich den Zweig zu Eltz-Bliescastell (wo die Eltzer als Trierer Amtmänner saßen) und Johann Philipp den Zweig zu Eltz-Waibling. Schließlich entstand durch Johann Adolph, Sohn von Friedrich von Eltz auf Bliescastell, die Linie Eltz-Rodendorf. Die Herrschaft Rodendorf (später Rotendorf genannt, heute Château-Rouge, Departement Moselle, Lothringen) gelangte durch Johann Adolphs Gemahlin Katharina von Brandscheid 1583 zunächst hälftig und im 18. Jahrhundert ganz in den Besitz der Eltz-Rodendorf, die ab 1681 auch das lothringische Freisdorf und von 1762 bis 1812 die Burg Bourscheid besaßen.

Ein Sohn des Johann Adolph von Eltz-Rodendorf war Lutheraner und Amtmann des protestantischen Pfälzer Kurfürsten Friedrich IV. Als dessen Sohn Friedrich V. 1619 die Wahl zum "Winterkönig" von Böhmen annahm, löste er den Dreißigjährigen Krieg aus. In dessen Verlauf wurde der Sohn des Amtmanns, Johann Eberhard zu Eltz, 1626/27 Kanzler im Fürstentum Braunschweig-Wolfenbüttel und ab 1628 Kanzler Wallensteins in Mecklenburg. Sein Bruder Philipp Samson zu Eltz heiratete die Erbtochter des Wolfenbütteler Kanzlers Barthold von Rutenberg, Erbin von Schloss Rethmar bei Hannover, und begründete die protestantische braunschweigische Linie. Dessen Sohn Friedrich Casimir zu Eltz (1634–1682) heiratete 1664 Barbara Margaretha von Pfuel (1649–1695), eine Tochter des Generals Adam von Pfuel. Er wurde Berghauptmann und erwarb zudem Amt, Gut und Schloss Walbeck im Ostharz. Die Linie erlosch mit dem Tod seines Sohnes, des kurbraunschweigischen Geheimrats und Großvogts von Celle, Philipp Adam zu Eltz, im Jahre 1727.

1732 gelangte mit Philipp Karl von Eltz-Kempenich (1665–1743) erneut ein Spross der Eltz zu erzbischöflichen und kurfürstlichen Würden. Er war der Sohn von Johann Anton zu Eltz und dessen Gattin Anna Maria Antonie Schenk von Schmittburg. Philipp Karl starb 1743 als Erzbischof und Kurfürst von Mainz. Sein jüngerer Bruder Karl Anton Ernst († 1736) von Eltz erhielt 1733 von Kaiser Karl VI. am 9. November 1733 zu Wien das Palatinat (in primogenitur) und am gleichen Tag den Reichsgrafenstand. Der Familie wurde außerdem am 16. November 1737 gestattet, das Wappen und den Namen der Faust von Stromberg mit dem ihren zu vereinigen. Grund war die Heirat von Anselm Kasimir Franz (* 1709; † 1778), ein Sohn des ersten Grafen zu Eltz, mit Maria Eva Johanna Freiin Faust von Stromberg († 1800), Erbtochter des Freiherren Friedrich Dietrich Joseph Faust von Stromberg und letzte Vertreterin dieses Geschlechts. Das Paar und ihre Nachkommen führten bzw. führen den vereinigten Namen, verheiratete Agnaten in der Form Graf und Edler Herr bzw. Gräfin und Edle Herrin von und zu Eltz genannt Faust(in) von Stromberg. Die unverheirateten Agnaten führten den Titel Graf und Edler Sohn bzw. Gräfin und Edle Tochter. Nach BGB lautet der Name heute: "Graf" bzw. "Gräfin zu Eltz". Am 30. Dezember 1734 erhielt Anselm Kasimir Franz zusammen mit seinem Bruder Hugo Franz Carl auch das Indigenat im Königreich Ungarn.

Hugo Philipp Karl (* 1742 † 1818), ein Sohn von Anselm Kasimir Franz, erbte von seinem Onkel, dem Mainzer Kurfürsten Philipp Karl, die Herrschaft Vukovar im damaligen Königreich Ungarn (heute Kroatien). Dort wurde ab 1749 das Schloss Eltz errichtet. Sein vollständiger Titel lautete: Hugo Philipp Karl, des Heiligen Römischen Reiches und des Königreiches Ungarn Graf und Edler Herr zu Eltz, genannt Faust von Stromberg, Graf und Herr zu Vukovar, Erbherr zu Trappstadt, Vendersheim, Römelheim und Leyen, Herr zu Burggrafenrode und Wierschheim, Pfandherr zu Schmidtburg, kaiserlicher Wirklicher Geheimer Rat, Kommandeur des kaiserlichen Sankt Josephsordens, kurmainzischer Wirklicher Geheimer Rat und Oberstallmeister, Oberamtmann zu Oberlahnstein und Gerresheim, kurtrierischer Wirklicher Geheimer Rat, Erbmarschall und Oberamtmann zu Mayen, Monreal und Kayserzesch. Die kurtrierische Hofkammer kündigte im Jahre 1776 die Pfandschaft der Burg Kempenich und machte diese zu einer Amtsburg. Hugo Philipp Karl verlor dann durch die Französische Revolution auch einen großen Teil seiner Ämter, Würden und Einkünfte in den Rheinlanden, denn er wurde während der französischen Herrschaft am Rhein von 1794 bis 1815 als Emigrant behandelt. Seine Besitztümer am Rhein und in der Nähe von Trier wurden eingezogen. Die Burg Eltz und die dazugehörigen Güter waren der Kommandantur in Koblenz unterstellt. Als sich später herausstellte, dass Graf Hugo Philipp nicht emigriert, sondern in Mainz geblieben war, kam er 1797 wieder zur Nutznießung seiner Güter und Renten. Er wurde 1815 durch den Kauf des 'Rübenacher Hauses' der Burg Eltz sowie des dazugehörigen Grundbesitzes der Freiherren von Eltz-Rübenach alleiniger Besitzer der Stammburg, die seither ungeteilt in der Hand der gräflichen Linie Eltz-Kempenich verblieb.

Während des 18. Jahrhunderts gehörten die Grafen zu Eltz, wegen des Besitzes von Burg-Gräfenrode (ein Drittel), zur  Reichsritterschaft im Ritterkanton Mittelrhein. Wegen der Ganerbschaft Burg Layen (ein Viertel) und dem zugehörigen Besitz in Rümmelsheim waren sie im Ritterkanton Oberrhein des Rheinischen Ritterkreises immatrikuliert. Ab Mitte des 18. Jahrhunderts gehörten die Herren zu Eltz auch zum Ritterkanton Baunach des Fränkischen Ritterkreises.

Aus der gräflichen Linie stammt Antonia Maria zu Eltz, die am 13. September 1756 zur Äbtissin und damit Reichsfürstin in Munsterbilzen erwählt wurde.

Vom Ende des Alten Reichs bis heute
Emmerich Graf zu Eltz († 1844), kaiserlicher Kämmerer, war zweimal verheiratet, in erster Ehe mit Maria Henriette Gräfin von Colloredo-Mansfeld († 1814) und in zweiter Ehe ab 1821 mit Maria Gräfin Samogy von Medgyes. Aus erster Ehe kamen drei Töchter, von denen Isabella (* 1795) den Fürsten Carl Anselm von Thurn und Taxis heiratete. Von ihren Onkeln, Emmerichs Brüdern, wurden Clemens (* 1770) Domherr zu Trier, Speyer und des Ritterstifts St. Alban, Lothar (* 1782) Domherr zu Mainz und Trier, August (* 1783) kaiserlicher Kämmerer und Feldmarschallleutnant und Franz (* 1786) Geheimrat, Feldmarschalleutnant und Oberhofmeister bei Erzherzogin Hildegard.

Graf Jacob von und zu Eltz gen. Faust von Stromberg (* 1779 † 1844) war Präsident der Ersten Kammer der Nassauischen Landstände. Aus seiner Ehe mit Maria Anna Freiin Wambolt von Umstadt († 1852) stammt der Sohn Karl (* 1823), der – wie auch sein Vater – kaiserlicher Kämmerer wurde. Er heiratete 1853 die Witwe seines Bruders Hugo († 1848), Ludvine Gräfin Pejácsevich von Veröcze (* 1823).

Jacob Graf und Edler Herr von und zu Eltz genannt Faust von Stromberg (* 1860; † 1906), Fideikommissherr auf Burg Eltz in der Eifel, Majoratsherr auf Eltville im Rheingau und Schloss Eltz in Vukovar (Slawonien, heute Kroatien), kaiserlich und königlicher Kämmerer, heiratete Prinzessin Marie von Lobkowicz aus dem Hause Mělník. Der Ehe entspross die Sternkreuzordensdame Lidwine Fürstin von Clary und Aldringen, Ehefrau des Fürsten Alfons von Clary und Aldringen (* 1887; † 1978).

Ein bedeutender Vertreter der Familie aus der jüngsten Zeit war Jakob Graf von und zu Eltz (* 1921; † 2006). Er wurde Ehren- und Devotions-Großkreuzbailli sowie Mitglied des Souveränen Rates des Malteserordens in Rom. 1964 bis 1976 war Jakob Graf von und zu Eltz Präsident des Rheingauer Weinbauverbandes und langjähriger Dozent für Weinrecht und Weinwirtschaft an der Mainzer Johannes Gutenberg-Universität. Von 1992 bis 2000 war er, als kroatischer Staatsbürger, Abgeordneter im Kroatischen Parlament.

Standeserhebungen
Hugo Friedrich zu Eltz, Domdechant in Trier, und das Gesamtgeschlecht erhielten am 19. Juni 1646 zu Linz von Kaiser Ferdinand III. eine Bestätigung des Herrenstandes und die Verleihung des Titels Edler Herr.

Carl Anton Ernst Edler Herr zu Eltz, kurfürstlich Mainzer Kämmerer, Rat, Amtmann und Hofmeister, kurfürstlich Trierer Geheimrat und Amtmann, Erbmarschall im Kurfürstentum Trier, wurde am 9. November 1733 von Kaiser Karl VI. zu Wien als kaiserlicher Wirklicher Geheimer Rat zusammen mit seinen Brüdern Damian Henrich, Domherr zu Trier und kurfürstlich Mainzer Geheimrat, und Philipp Adolph, Komtur der Balley Muffendorf des Deutschen Ordens, in den Reichsgrafenstand mit der Anrede Hoch- und Wohlgeboren erhoben.

Eine Immatrikulation bei der Grafenklasse der Adelsmatrikel im Königreich Bayern erhielt Hugo Graf und Edler Herr von und zu Eltz genannt Faust von Stromberg auf Trappstadt und seine in Bayern lebenden Geschwister am 16. August 1816.

Der aus der Linie Eltz-Rübenach stammende Emmerich Joseph Freiherr von Eltz zu Wahn erhielt am 20. Juni 1827 eine preußische Anerkennung des Freiherrenstandes durch Ministerialreskript. Die unverheirateten Nachkommen führen den Namen Freiherr und Edler Sohn bzw. Freiin und Edle Tochter von und zu Eltz-Rübenach. Emmerich Joseph und Clemens Wenzelslaus Freie und Edle Herren von und zu Eltz-Rübenach wurden, nach Eingabe des Hauses Wahn im Regierungsbezirk Köln vom 19. Juni 1829, bei der Adelsmatrikel der preußischen Rheinprovinz in der Klasse der Freiherren unter der Nummer 48 eingetragen.

Besitzungen
Die gräfliche Linie "vom goldenen Löwen" (nach der Wappenfarbe benannt), Eltz-Kempenich, besitzt bis heute die Burg Eltz und den Eltzer Hof zu Eltville. Die seit über 800 Jahren im Familienbesitz befindliche Burg ist als Museum der Öffentlichkeit zugänglich, jetziger Eigentümer ist Dr. Karl Graf und Edler Herr von und zu Eltz-Kempenich genannt Faust von Stromberg. Die Weinberge in Eltville wurden 1976 aus wirtschaftlichen Gründen und anlässlich des Ausbaus einer Bundesstraße verkauft. Zu den ehemaligen Besitzungen zählen die Eltzer Höfe in Mainz und Boppard sowie das Schloss Eltz in Vukovar/Kroatien.

Die freiherrliche Linie "vom silbernen Löwen", Eltz-Rübenach, ist bis heute auf der Burg Kühlseggen wohnhaft, während sie das Burghaus in Koblenz-Rübenach (seit 1316 im Besitz der Familie) und Schloss Wahn verpachtet hat.

Wappen

Stammwappen
Das Stammwappen derer von Eltz ist von Rot und Silber geteilt, oben ein wachsender goldener Löwe, unten ledig. Auf dem Helm mit rot-goldenen Helmdecken ein hermelingestulpter roter Sturmhut, aus dem ein goldener Löwe zwischen ein mit silbernen Herzen besätem offenen roten Flug hervorwächst.

Das Stammwappen derer von Eltz-Rübenach ist geteilt, oben in Rot ein wachsender zweischwänziger silberner Löwe, unten golden ohne Bild. Auf dem Helm mit rot-silbernen Helmdecken ein hermelingefütterter roter Hut, aus dem ein silberner Löwe zwischen ein mit silbernen Herzen bestreuten offenen roten Adlerflug hervorwächst.

Gräfliches Wappen
Das reichsgräfliche Wappen, verliehen 1733, ist geviert und belegt mit einem Mittelschild, darin das Stammwappen. 1 und 4 in Gold ein einwärtssehender rotbezungter schwarzer Adler, 2 und 3 in Schwarz ein einwärtsgekehrter goldener Greif. Das Wappen hat drei Helme, auf dem rechten mit schwarz-goldenen Decken der Adler, der mittlere mit rot silbernen Decken der Stammhelm und auf dem linken mit schwarz-goldenen Decken der Greif. Als Schildhalter zwei doppelschwänzige gekrönte rotbezungte goldene Löwen.

Wappenvereinigung Eltz und Faust von Stromberg
Das 1737 verliehene vereinigte Wappen der Eltz und Faust von Stromberg ist geteilt und oben einmal, unten zweimal gespalten, sowie belegt mit einem Mittelschild, darin das Stammwappen. 1 und 5 in Gold ein roter Balken und belegt mit einem kaiserlich-gekrönten schwarzen Doppeladler. 2 und 3 in Schwarz ein silberner Balken und belegt mit einem einwärtsgekehrten rotbezungten goldenen Greif, 4 von Gold und Rot zu 25 Plätzen geschacht, der erste
Platz mit einem sechsstrahligen schwarzen Stern belegt (Wappen der Faust von Stromberg). Das Wappen hat vier Helme mit rot-goldenen, der 4. Helm mit schwarz-silbernen Helmdecken. Auf dem ersten der Doppeladler, der zweite der Stammhelm mit einwärtsgekehrten Löwen, auf dem dritten ein mit gold-rotem Schach gestulpter roter Sturmhut, besteckt mit dem schwarzen Stern zwischen zwei von Gold und Rot bzw. Rot und Gold geteilten auswärtswehenden Sturmfahnen an goldenen Stangen (Helm der Faust von Stromberg), auf dem vierten Helm der Greif. Als Schildhalter zwei doppelschwänzige gekrönte rotbezungte goldene Löwen.

Wappensage
Die Herren Faust von Stromberg, die im Jahre 1729 ausstarben, führten einen von Rot und Gold in fünf Reihen geschachten Wappenschild, das oberste (erste) Schach mit einem schwarzen Stern belegt. Folgende Sage will die Entstehung des Wappens erklären: Ein Stromberg spielte einst mit seinem Lehnsherren, einem Pfalzgrafen am Rhein, Schach. Sie gerieten in Streit und der Pfalzgraf beschimpfte den Stromberg, worauf dieser mit der Faust nach ihm schlug. Daraufhin zog der Pfalzgraf das Gut Stromberg ein und der Kaiser bestrafte den Stromberg damit, dass er und seine Nachkommen sich Faust schreiben und das Schachbrett im Wappen führen mussten. Der schwarze Stern in Gold soll an den Faustschlag erinnern. Die Grafen von Eltz nahmen als nächste Verwandte der ausgestorbenen Familie dieses Wappen in ihren Schild auf.

Namensträger

 Arnold von Eltz († 1330), Domherr zu Trier, seit 1324 Bischof von Cammin
 Robin von Eltz, von 1367 bis 1392 Heermeister des Deutschen Ordens in Livland
 Georg von Eltz († 1532), Komtur des Deutschen Ordens
 Jakob III. von Eltz (* 1510; † 1581), Kurfürst und Erzbischof von Trier
 Johann Eberhard zu Eltz (* 1594; † 1655), Kanzler im Fürstentum Braunschweig-Wolfenbüttel und mecklenburgischer Kanzler unter Wallenstein
 Friedrich Casimir zu Eltz (* 1634; † 1682), hannoverscher Berghauptmann und kursächsischer Rittergutsbesitzer
 Philipp Adam zu Eltz (* 1665; † 1727), hannoverscher Geheimer Rat und kursächsischer Rittergutsbesitzer
 Philipp Karl von Eltz (* 1665; † 1743), Kurfürst und Erzbischof von Mainz
 Hugo Franz Carl von und zu Eltz-Kempenich (* 1701; † 1799), Reichsgraf, Geheimrat, Dompropst zu Mainz, 1732 bis 1779 Kurmainzischer Statthalter im Eichsfeld
 Maria Theresia von Eltz-Rodendorf (* 1770; † 1803), Herrin zu Bourscheid und der Herrschaft Freisdorf
 Johann Philipp Jakob Nepomuk von und zu Eltz (* 1779; † 1844), Präsident der nassauischen Herrenbank
 Paul Freiherr von Eltz-Rübenach (* 1875; † 1943), deutscher Reichsverkehrsminister
 Kuno von Eltz-Rübenach (* 1904; † 1945), Reichstagsabgeordneter der NSDAP und SS-Brigadeführer
 Jakob Graf von und zu Eltz (* 1921; † 2006), deutscher Winzer

 Johannes Graf zu Eltz (* 1957), katholischer Priester, Stadtdekan von Frankfurt am Main
 Theresa von Eltz (* 1978), deutsche Filmregisseurin

Briefadelige Familien
Das Genealogische Handbuch des Adels nennt noch eine weitere Familie gleichen Namens, die ebenfalls aus dem Rheinland stammt, deren Ursprung jedoch nicht geklärt ist. Sie beginnt ihre Stammreihe mit dem Faßbinder und Zunftmeister in Koblenz Johann Anton von Eltz (er erscheint 1610 bis 1635 urkundlich). Dessen Nachkommen legten aus ungeklärten Gründen für 2 Generationen das Adelsprädikat "von" ab.
Am 14. September 1797 war der Nachkomme Johann Franz Joseph von Eltz von der revolutionären Regierung gezwungen, zur Pflanzung des Freiheitsbaums auf dem Paradeplatz in Koblenz alle an die Feudalität erinnernden Urkunden zu verbrennen, woraufhin die Familie ins Baltikum auswanderte. Sein Enkel Hugo von Eltz, Güterdirektor zu Alexejewskoje, Kreis Jamburg im Gouvernement Sankt Petersburg, erhielt am 7. August 1856 zu Berlin durch Heroldsamtsreskript eine preußische Adelsbestätigung.

Ein Philipp Eltz, fürsterzbischöflich Olmützer Hofrat, erhielt am 2. November 1868 durch Allerhöchsten Erlass die österreichische Adelsanerkennung (Diplom ausgestellt am 15. Dezember 1868 zu Wien).

Einzelnachweise

Literatur
 Otto Hupp: Münchener Kalender 1904. Verlagsanstalt Buch u. Kunstdruckerei AG, München / Regensburg 1904.
 Ernst Heinrich Kneschke: Neues allgemeines deutsches Adels-Lexicon. Band 3, Friedrich Voigt's Buchhandlung, Leipzig 1861, S. 97–99. (Digitalisat)

 Leopold von Zedlitz-Neukirch: Neues preussisches Adelslexicon. Band 2, Gebrüder Reichenbach, Leipzig 1836, S. 125–128. (Digitalisat)
 Genealogisches Handbuch des Adels, Adelslexikon. Band III, Band 61 der Gesamtreihe C. A. Starke Verlag, Limburg (Lahn) 1975, , S. 134–136.
 Genealogisches Taschenbuch der deutschen gräflichen Häuser, 1836, S.169f

Weblinks

 Wappen derer von Eltz in Johann Siebmachers Wappenbuch (1605)

 www.burg-eltz.de

Deutsches Adelsgeschlecht
Rheinländisches Adelsgeschlecht