written ) {
+ this.node = entity;
+ this.written = written;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see org.jboss.dna.connector.store.jpa.util.Serializer.LargeValues#getMinimumSize()
+ */
+ public long getMinimumSize() {
+ return minimumSizeOfLargeValuesInBytes;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see org.jboss.dna.connector.store.jpa.util.Serializer.LargeValues#read(org.jboss.dna.graph.property.ValueFactories,
+ * byte[], long)
+ */
+ public Object read( ValueFactories valueFactories,
+ byte[] hash,
+ long length ) throws IOException {
+ String hashStr = StringUtil.getHexString(hash);
+ // Find the large value ...
+ LargeValueEntity entity = entityManager.find(LargeValueEntity.class, hashStr);
+ if (entity != null) {
+ // Find the large value from the existing property entity ...
+ byte[] data = entity.getData();
+ if (entity.isCompressed()) {
+ InputStream stream = new GZIPInputStream(new ByteArrayInputStream(data));
+ try {
+ data = IoUtil.readBytes(stream);
+ } finally {
+ stream.close();
+ }
+ }
+ return valueFactories.getValueFactory(entity.getType()).create(data);
+ }
+ throw new IOException(JpaConnectorI18n.unableToReadLargeValue.text(getSourceName(), hashStr));
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see org.jboss.dna.connector.store.jpa.util.Serializer.LargeValues#write(byte[], long,
+ * org.jboss.dna.graph.property.PropertyType, java.lang.Object)
+ */
+ public void write( byte[] hash,
+ long length,
+ PropertyType type,
+ Object value ) throws IOException {
+ if (value == null) return;
+ String hashStr = StringUtil.getHexString(hash);
+ if (written != null) written.add(hashStr);
+
+ // Look for an existing value in the collection ...
+ for (LargeValueEntity existing : node.getLargeValues()) {
+ if (existing.getHash().equals(hashStr)) {
+ // Already associated with this properties entity
+ return;
+ }
+ }
+ LargeValueEntity entity = entityManager.find(LargeValueEntity.class, hashStr);
+ if (entity == null) {
+ // We have to create the large value entity ...
+ entity = new LargeValueEntity();
+ entity.setCompressed(compressData);
+ entity.setHash(hashStr);
+ entity.setLength(length);
+ entity.setType(type);
+ ValueFactories factories = context.getValueFactories();
+ byte[] bytes = null;
+ switch (type) {
+ case BINARY:
+ Binary binary = factories.getBinaryFactory().create(value);
+ InputStream stream = null;
+ try {
+ binary.acquire();
+ stream = binary.getStream();
+ if (compressData) stream = new GZIPInputStream(stream);
+ bytes = IoUtil.readBytes(stream);
+ } finally {
+ try {
+ if (stream != null) stream.close();
+ } finally {
+ binary.release();
+ }
+ }
+ break;
+ case URI:
+ // This will be treated as a string ...
+ default:
+ String str = factories.getStringFactory().create(value);
+ if (compressData) {
+ ByteArrayOutputStream bs = new ByteArrayOutputStream();
+ OutputStream strStream = new GZIPOutputStream(bs);
+ try {
+ IoUtil.write(str, strStream);
+ } finally {
+ strStream.close();
+ }
+ bytes = bs.toByteArray();
+ } else {
+ bytes = str.getBytes();
+ }
+ break;
+ }
+ entity.setData(bytes);
+ entityManager.persist(entity);
+ }
+ // Now associate the large value with the properties entity ...
+ assert entity.getHash() != null;
+ node.getLargeValues().add(entity);
+ }
+
+ }
+
+}
Property changes on: extensions\dna-connector-store-jpa\src\main\java\org\jboss\dna\connector\store\jpa\model\simple\SimpleJpaRepository.java
___________________________________________________________________
Added: svn:keywords
+ Id Revision
Added: svn:eol-style
+ LF
Index: extensions/dna-connector-store-jpa/src/main/java/org/jboss/dna/connector/store/jpa/model/simple/SimpleModel.java
===================================================================
--- extensions/dna-connector-store-jpa/src/main/java/org/jboss/dna/connector/store/jpa/model/simple/SimpleModel.java (revision 0)
+++ extensions/dna-connector-store-jpa/src/main/java/org/jboss/dna/connector/store/jpa/model/simple/SimpleModel.java (revision 0)
@@ -0,0 +1,115 @@
+/*
+ * JBoss DNA (http://www.jboss.org/dna)
+ * See the COPYRIGHT.txt file distributed with this work for information
+ * regarding copyright ownership. Some portions may be licensed
+ * to Red Hat, Inc. under one or more contributor license agreements.
+ * See the AUTHORS.txt file in the distribution for a full listing of
+ * individual contributors.
+ *
+ * JBoss DNA is free software. Unless otherwise indicated, all code in JBoss DNA
+ * is licensed to you under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * JBoss DNA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.connector.store.jpa.model.simple;
+
+import org.hibernate.ejb.Ejb3Configuration;
+import org.jboss.dna.connector.store.jpa.JpaConnectorI18n;
+import org.jboss.dna.connector.store.jpa.JpaSource;
+import org.jboss.dna.connector.store.jpa.Model;
+import org.jboss.dna.connector.store.jpa.model.common.NamespaceEntity;
+import org.jboss.dna.connector.store.jpa.model.common.WorkspaceEntity;
+import org.jboss.dna.graph.connector.RepositoryConnection;
+import org.jboss.dna.graph.request.CopyBranchRequest;
+import org.jboss.dna.graph.request.DeleteBranchRequest;
+import org.jboss.dna.graph.request.MoveBranchRequest;
+import org.jboss.dna.graph.request.ReadBranchRequest;
+
+/**
+ * Database model that stores each node (transparently) and its properties (opaquely) in a single row. Large property values are
+ * stored separately and can be shared between nodes.
+ *
+ * The set of tables used in this model includes:
+ *
+ * - Namespaces - the set of namespace URIs used in paths, property names, and property values.
+ * - Nodes - each node along with its name, seralized properties, parent, UUID, and position within its parent. This approach
+ * makes it possible to efficiently work with nodes containing large numbers of children, where adding and removing child nodes is
+ * largely independent of the number of children. Also, working with properties is also completely independent of the number of
+ * child nodes.
+ * - Large values - property values larger than a certain size will be broken out into this table, where they are tracked by
+ * their SHA-1 hash and shared by all properties that have that same value. The values are stored in a binary (and optionally
+ * compressed) form.
+ * - ReferenceChanges - the references from one node to another
+ * - Subgraph - a working area for efficiently computing the space of a subgraph; see below
+ * - Change log - a record of the changes that have been made to the repository. This is used to distribute change events across
+ * multiple distributed processes, and to allow a recently-connected client to identify the set of changes that have been made
+ * since a particular time or date. Changes are serialized into a binary, compressed format.
+ * - Options - the parameters for this store's configuration (common to all models)
+ *
+ *
+ * Subgraph queries
+ *
+ * This database model contains two tables that are used in an efficient mechanism to find all of the nodes in the subgraph below
+ * a certain node. This process starts by creating a record for the subgraph query, and then proceeds by executing a join to find
+ * all the children of the top-level node, and inserting them into the database (in a working area associated with the subgraph
+ * query). Then, another join finds all the children of those children and inserts them into the same working area. This continues
+ * until the maximum depth has been reached, or until there are no more children (whichever comes first). All of the nodes in the
+ * subgraph are then represented by records in the working area, and can be used to quickly and efficient work with the subgraph
+ * nodes. When finished, the mechanism deletes the records in the working area associated with the subgraph query.
+ *
+ *
+ * This subgraph query mechanism is extremely efficient, performing one join/insert statement per level of the subgraph,
+ * and is completely independent of the number of nodes in the subgraph. For example, consider a subgraph of node A, where A has
+ * 10 children, and each child contains 10 children, and each grandchild contains 10 children. This subgraph has a total of 1111
+ * nodes (1 root + 10 children + 10*10 grandchildren + 10*10*10 great-grandchildren). Finding the nodes in this subgraph would
+ * normally require 1 query per node (in other words, 1111 queries). But with this subgraph query mechanism, all of the nodes in
+ * the subgraph can be found with 1 insert plus 4 additional join/inserts.
+ *
+ *
+ * This mechanism has the added benefit that the set of nodes in the subgraph are kept in a working area in the database, meaning
+ * they don't have to be pulled into memory.
+ *
+ *
+ * Subgraph queries are used to efficiently process a number of different requests, including {@link ReadBranchRequest},
+ * {@link DeleteBranchRequest}, {@link MoveBranchRequest}, and {@link CopyBranchRequest}. Processing each of these kinds of
+ * requests requires knowledge of the subgraph, and in fact all but the ReadBranchRequest need to know the complete
+ * subgraph.
+ *
+ */
+public class SimpleModel extends Model {
+
+ public SimpleModel() {
+ super("Simple", JpaConnectorI18n.simpleModelDescription);
+ }
+
+ /**
+ * Configure the entity class that will be used by JPA to store information in the database.
+ *
+ * @param configurator the Hibernate {@link Ejb3Configuration} component; never null
+ */
+ @Override
+ public void configure( Ejb3Configuration configurator ) {
+ // Add the annotated classes ...
+ configurator.addAnnotatedClass(WorkspaceEntity.class);
+ configurator.addAnnotatedClass(NamespaceEntity.class);
+ configurator.addAnnotatedClass(LargeValueEntity.class);
+ configurator.addAnnotatedClass(NodeEntity.class);
+ configurator.addAnnotatedClass(SubgraphNodeEntity.class);
+ configurator.addAnnotatedClass(SubgraphQueryEntity.class);
+ }
+
+ @Override
+ public RepositoryConnection createConnection( JpaSource source ) {
+ return new SimpleJpaConnection(source);
+ }
+}
Property changes on: extensions\dna-connector-store-jpa\src\main\java\org\jboss\dna\connector\store\jpa\model\simple\SimpleModel.java
___________________________________________________________________
Added: svn:keywords
+ Id Revision
Added: svn:eol-style
+ LF
Index: extensions/dna-connector-store-jpa/src/main/java/org/jboss/dna/connector/store/jpa/model/simple/SimpleRequestProcessor.java
===================================================================
--- extensions/dna-connector-store-jpa/src/main/java/org/jboss/dna/connector/store/jpa/model/simple/SimpleRequestProcessor.java (revision 0)
+++ extensions/dna-connector-store-jpa/src/main/java/org/jboss/dna/connector/store/jpa/model/simple/SimpleRequestProcessor.java (revision 0)
@@ -0,0 +1,151 @@
+package org.jboss.dna.connector.store.jpa.model.simple;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import javax.persistence.EntityTransaction;
+import org.jboss.dna.connector.store.jpa.JpaConnectorI18n;
+import org.jboss.dna.connector.store.jpa.JpaSource;
+import org.jboss.dna.graph.ExecutionContext;
+import org.jboss.dna.graph.Location;
+import org.jboss.dna.graph.connector.map.MapNode;
+import org.jboss.dna.graph.connector.map.MapRequestProcessor;
+import org.jboss.dna.graph.observe.Observer;
+import org.jboss.dna.graph.property.PathFactory;
+import org.jboss.dna.graph.request.CloneWorkspaceRequest;
+import org.jboss.dna.graph.request.CreateWorkspaceRequest;
+import org.jboss.dna.graph.request.InvalidRequestException;
+import org.jboss.dna.graph.request.ReadBranchRequest;
+import org.jboss.dna.graph.request.processor.RequestProcessor;
+import com.google.common.collect.LinkedListMultimap;
+
+/**
+ * Extension of the {@link MapRequestProcessor} that provides a {@link #process(ReadBranchRequest)} implementation optimized for
+ * the {@link SimpleModel simple JPA model}. This class also provides some JPA-specific functionality for the ability to control
+ * whether {@link JpaSource#isCreatingWorkspacesAllowed() creating workspaces is allowed}.
+ */
+public class SimpleRequestProcessor extends MapRequestProcessor {
+
+ private final SimpleJpaRepository repository;
+ private final PathFactory pathFactory;
+
+ public SimpleRequestProcessor( ExecutionContext context,
+ SimpleJpaRepository repository,
+ Observer observer ) {
+ super(context, repository, observer);
+
+ this.repository = repository;
+ this.pathFactory = context.getValueFactories().getPathFactory();
+ }
+
+ @Override
+ public void close() {
+ EntityTransaction tx = repository.entityManager().getTransaction();
+ if (tx != null) {
+ tx.commit();
+ }
+ super.close();
+ }
+
+ /**
+ * Override the {@link RequestProcessor#process(ReadBranchRequest) default handling} for a read branch request to optimize the
+ * queries involved.
+ *
+ * @param request the request to read
+ */
+ @Override
+ public void process( ReadBranchRequest request ) {
+ SimpleJpaRepository.Workspace workspace = (SimpleJpaRepository.Workspace)getWorkspace(request, request.inWorkspace());
+
+ int maximumDepth = request.maximumDepth();
+ List branch = workspace.getBranch(request.at(), maximumDepth);
+
+ if (!branch.isEmpty()) {
+ Map locations = new HashMap(branch.size());
+
+ /*
+ * Add the first (root) node to the request
+ */
+ MapNode root = branch.get(0);
+ Location rootLocation = getActualLocation(request.at(), root);
+ request.setActualLocationOfNode(rootLocation);
+ locations.put(root.getUuid(), new LocationWithDepth(rootLocation, 0));
+
+ /*
+ * The obvious thing to do here would be to call root.getChildren(), but that would
+ * result in the JPA implementation running an extra query to load the collection of
+ * children for the entity even though we've already loaded all of the children
+ * with the call to workspace.getBranch(...) earlier.
+ *
+ * We'll build the list of children ourselves knowing that all children are in the result set.
+ *
+ * The concrete type is used in the variable declaration instead of the relevant interface
+ * (Multimap) because we need to cast the result of a .get(UUID) operation
+ * to a List below and the interface only guarantees a Collection.
+ */
+ LinkedListMultimap childrenByParentUuid = LinkedListMultimap.create();
+
+ /*
+ * We don't want to process the root node (the first node) in this loop
+ * as this would cause us to unnecessarily load the root node's parent node.
+ */
+ for (int i = 1; i < branch.size(); i++) {
+ MapNode node = branch.get(i);
+ UUID parentUuid = node.getParent().getUuid();
+
+ LocationWithDepth parentLocation = locations.get(parentUuid);
+ Location nodeLocation = locationFor(parentLocation.getLocation(), node);
+ locations.put(node.getUuid(), new LocationWithDepth(nodeLocation, parentLocation.getDepth() + 1));
+
+ childrenByParentUuid.put(parentUuid, locationFor(locations.get(parentUuid).getLocation(), node));
+ }
+
+ request.setChildren(rootLocation, childrenByParentUuid.get(root.getUuid()));
+ request.setProperties(rootLocation, root.getProperties().values());
+
+ /*
+ * Process the subsequent nodes
+ */
+ for (int i = 1; i < branch.size(); i++) {
+ MapNode node = branch.get(i);
+
+ UUID nodeUuid = node.getUuid();
+ LocationWithDepth nodeLocation = locations.get(nodeUuid);
+ if (nodeLocation.getDepth() < maximumDepth) {
+ request.setChildren(nodeLocation.getLocation(), childrenByParentUuid.get(nodeUuid));
+ request.setProperties(nodeLocation.getLocation(), node.getProperties().values());
+ }
+ }
+ }
+
+ setCacheableInfo(request);
+ }
+
+ private Location locationFor( Location parentLocation,
+ MapNode node ) {
+ return Location.create(pathFactory.create(parentLocation.getPath(), node.getName()), node.getUuid());
+ }
+
+ @Override
+ public void process( CreateWorkspaceRequest request ) {
+ if (!repository.creatingWorkspacesAllowed()) {
+ String msg = JpaConnectorI18n.unableToCreateWorkspaces.text(getSourceName());
+ request.setError(new InvalidRequestException(msg));
+ return;
+ }
+
+ super.process(request);
+ }
+
+ @Override
+ public void process( CloneWorkspaceRequest request ) {
+ if (!repository.creatingWorkspacesAllowed()) {
+ String msg = JpaConnectorI18n.unableToCreateWorkspaces.text(getSourceName());
+ request.setError(new InvalidRequestException(msg));
+ return;
+ }
+
+ super.process(request);
+ }
+}
Property changes on: extensions\dna-connector-store-jpa\src\main\java\org\jboss\dna\connector\store\jpa\model\simple\SimpleRequestProcessor.java
___________________________________________________________________
Added: svn:keywords
+ Id Revision
Added: svn:eol-style
+ LF
Index: extensions/dna-connector-store-jpa/src/main/java/org/jboss/dna/connector/store/jpa/model/simple/SubgraphNodeEntity.java
===================================================================
--- extensions/dna-connector-store-jpa/src/main/java/org/jboss/dna/connector/store/jpa/model/simple/SubgraphNodeEntity.java (revision 0)
+++ extensions/dna-connector-store-jpa/src/main/java/org/jboss/dna/connector/store/jpa/model/simple/SubgraphNodeEntity.java (revision 0)
@@ -0,0 +1,175 @@
+/*
+ * JBoss DNA (http://www.jboss.org/dna)
+ * See the COPYRIGHT.txt file distributed with this work for information
+ * regarding copyright ownership. Some portions may be licensed
+ * to Red Hat, Inc. under one or more contributor license agreements.
+ * See the AUTHORS.txt file in the distribution for a full listing of
+ * individual contributors.
+ *
+ * JBoss DNA is free software. Unless otherwise indicated, all code in JBoss DNA
+ * is licensed to you under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * JBoss DNA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.connector.store.jpa.model.simple;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.NamedQueries;
+import javax.persistence.NamedQuery;
+import javax.persistence.Table;
+import org.hibernate.annotations.Index;
+
+/**
+ * Represents a single node that appears in a subgraph.
+ *
+ * @see SubgraphQueryEntity
+ */
+@Entity
+@org.hibernate.annotations.Table( appliesTo = "DNA_SUBGRAPH_NODES", indexes = @Index( name = "QUERYID_INX", columnNames = {
+ "QUERY_ID", "UUID", "DEPTH"} ) )
+@Table( name = "DNA_SUBGRAPH_NODES" )
+@NamedQueries( {
+ @NamedQuery( name = "SubgraphNodeEntity.insertChildren", query = "insert into SubgraphNodeEntity(queryId,nodeUuid,depth,parentIndexInParent,indexInParent) select parentNode.queryId, child.nodeUuidString, parentNode.depth+1, parentNode.indexInParent, child.indexInParent from NodeEntity child, SubgraphNodeEntity parentNode where child.workspaceId = :workspaceId and child.parent.nodeUuidString = parentNode.nodeUuid and parentNode.queryId = :queryId and parentNode.depth = :parentDepth" ),
+ @NamedQuery( name = "SubgraphNodeEntity.getCount", query = "select count(*) from SubgraphNodeEntity where queryId = :queryId" ),
+ @NamedQuery( name = "SubgraphNodeEntity.getNodeEntitiesWithLargeValues", query = "select props from NodeEntity props, SubgraphNodeEntity node where props.workspaceId = :workspaceId and props.nodeUuidString = node.nodeUuid and node.queryId = :queryId and node.depth >= :depth and size(props.largeValues) > 0" ),
+ @NamedQuery( name = "SubgraphNodeEntity.getChildEntities", query = "select child from NodeEntity child, SubgraphNodeEntity node where child.workspaceId = :workspaceId and child.nodeUuidString = node.nodeUuid and node.queryId = :queryId and node.depth >= :depth and node.depth <= :maxDepth order by node.depth, node.parentIndexInParent, node.indexInParent" ),
+ // @NamedQuery( name = "SubgraphNodeEntity.getInternalReferences", query =
+ // "select ref from ReferenceEntity as ref where ref.id.workspaceId = :workspaceId and ref.id.toUuidString in ( select node.nodeUuid from SubgraphNodeEntity node where node.queryId = :queryId) and ref.id.fromUuidString in (select node.nodeUuid from SubgraphNodeEntity node where node.queryId = :queryId)"
+ // ),
+ // @NamedQuery( name = "SubgraphNodeEntity.getOutwardReferences", query =
+ // "select ref from ReferenceEntity as ref where ref.id.workspaceId = :workspaceId and ref.id.toUuidString not in ( select node.nodeUuid from SubgraphNodeEntity node where node.queryId = :queryId) and ref.id.fromUuidString in (select node.nodeUuid from SubgraphNodeEntity node where node.queryId = :queryId)"
+ // ),
+ // @NamedQuery( name = "SubgraphNodeEntity.getInwardReferences", query =
+ // "select ref from ReferenceEntity as ref where ref.id.workspaceId = :workspaceId and ref.id.toUuidString in ( select node.nodeUuid from SubgraphNodeEntity node where node.queryId = :queryId) and ref.id.fromUuidString not in (select node.nodeUuid from SubgraphNodeEntity node where node.queryId = :queryId)"
+ // ),
+ @NamedQuery( name = "SubgraphNodeEntity.clearParentReferences", query = "update NodeEntity child set child.parent = null where child.workspaceId = :workspaceId and child.nodeUuidString in ( select node.nodeUuid from SubgraphNodeEntity node where node.queryId = :queryId and node.depth >= :depth )" ),
+ @NamedQuery( name = "SubgraphNodeEntity.deleteChildEntities", query = "delete NodeEntity child where child.workspaceId = :workspaceId and child.nodeUuidString in ( select node.nodeUuid from SubgraphNodeEntity node where node.queryId = :queryId and node.depth >= :depth )" ),
+ // @NamedQuery( name = "SubgraphNodeEntity.deleteReferences", query =
+ // "delete ReferenceEntity as ref where ref.id.workspaceId = :workspaceId and ref.id.fromUuidString in ( select node.nodeUuid from SubgraphNodeEntity node where node.queryId = :queryId )"
+ // ),
+ @NamedQuery( name = "SubgraphNodeEntity.deleteByQueryId", query = "delete SubgraphNodeEntity where queryId = :queryId" )} )
+public class SubgraphNodeEntity {
+
+ @Id
+ @Column( name = "ID" )
+ @GeneratedValue( strategy = GenerationType.AUTO )
+ private Long id;
+
+ @Column( name = "QUERY_ID", nullable = false, unique = false, updatable = false )
+ private Long queryId;
+
+ @Column( name = "UUID", updatable = false, nullable = false, length = 36 )
+ private String nodeUuid;
+
+ @Column( name = "DEPTH", updatable = false, nullable = false )
+ private int depth;
+
+ @Column( name = "PARENT_NUM", updatable = false, nullable = false )
+ private int parentIndexInParent;
+
+ @Column( name = "CHILD_NUM", updatable = false, nullable = false )
+ private int indexInParent;
+
+ public SubgraphNodeEntity() {
+ }
+
+ public SubgraphNodeEntity( Long queryId,
+ String nodeUuid,
+ int depth ) {
+ this.queryId = queryId;
+ this.nodeUuid = nodeUuid;
+ this.depth = depth;
+ }
+
+ /**
+ * @return id
+ */
+ public Long getId() {
+ return id;
+ }
+
+ /**
+ * @return depth
+ */
+ public int getDepth() {
+ return depth;
+ }
+
+ /**
+ * @return nodeUuid
+ */
+ public String getNodeUuid() {
+ return nodeUuid;
+ }
+
+ /**
+ * @return queryId
+ */
+ public Long getQueryId() {
+ return queryId;
+ }
+
+ /**
+ * @return indexInParent
+ */
+ public int getIndexInParent() {
+ return indexInParent;
+ }
+
+ /**
+ * @return parentIndexInParent
+ */
+ public int getParentIndexInParent() {
+ return parentIndexInParent;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public int hashCode() {
+ return id != null ? id.intValue() : 0;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see java.lang.Object#equals(java.lang.Object)
+ */
+ @Override
+ public boolean equals( Object obj ) {
+ if (obj == this) return true;
+ if (obj instanceof SubgraphNodeEntity) {
+ SubgraphNodeEntity that = (SubgraphNodeEntity)obj;
+ if (this.id.equals(that.id)) return true;
+ }
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see java.lang.Object#toString()
+ */
+ @Override
+ public String toString() {
+ return "" + id + " - Query " + queryId + "; depth=" + depth + "; node=" + nodeUuid + " at index " + indexInParent;
+ }
+
+}
Property changes on: extensions\dna-connector-store-jpa\src\main\java\org\jboss\dna\connector\store\jpa\model\simple\SubgraphNodeEntity.java
___________________________________________________________________
Added: svn:keywords
+ Id Revision
Added: svn:eol-style
+ LF
Index: extensions/dna-connector-store-jpa/src/main/java/org/jboss/dna/connector/store/jpa/model/simple/SubgraphQuery.java
===================================================================
--- extensions/dna-connector-store-jpa/src/main/java/org/jboss/dna/connector/store/jpa/model/simple/SubgraphQuery.java (revision 0)
+++ extensions/dna-connector-store-jpa/src/main/java/org/jboss/dna/connector/store/jpa/model/simple/SubgraphQuery.java (revision 0)
@@ -0,0 +1,388 @@
+/*
+ * JBoss DNA (http://www.jboss.org/dna)
+ * See the COPYRIGHT.txt file distributed with this work for information
+ * regarding copyright ownership. Some portions may be licensed
+ * to Red Hat, Inc. under one or more contributor license agreements.
+ * See the AUTHORS.txt file in the distribution for a full listing of
+ * individual contributors.
+ *
+ * JBoss DNA is free software. Unless otherwise indicated, all code in JBoss DNA
+ * is licensed to you under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * JBoss DNA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.connector.store.jpa.model.simple;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+import javax.persistence.EntityManager;
+import javax.persistence.NoResultException;
+import javax.persistence.Query;
+import org.jboss.dna.graph.ExecutionContext;
+import org.jboss.dna.graph.property.Path;
+
+/**
+ * Represents a temporary working area for a query that efficiently retrieves the nodes in a subgraph. This class uses the
+ * database to build up the content of the subgraph, and therefore requires write privilege on the database. The benefit is that
+ * it minimizes the amount of memory required to process the subgraph, plus the set of nodes that make up the subgraph can be
+ * produced with database joins.
+ *
+ * The use of database joins also produces another benefit: the number of SQL statements necessary to build the set of nodes in a
+ * subgraph is equal to the depth of the subgraph, regardless of the number of child nodes at any level.
+ *
+ */
+public class SubgraphQuery {
+
+ /**
+ * Create a query that returns a subgraph at and below the node with the supplied path and the supplied UUID.
+ *
+ * @param context the execution context; may not be null
+ * @param entities the entity manager; may not be null
+ * @param workspaceId the ID of the workspace; may not be null
+ * @param subgraphRootUuid the UUID (in string form) of the root node in the subgraph
+ * @param subgraphRootPath the path of the root node in the subgraph
+ * @param maxDepth the maximum depth of the subgraph, or 0 if there is no maximum depth
+ * @return the object representing the subgraph
+ */
+ public static SubgraphQuery create( ExecutionContext context,
+ EntityManager entities,
+ Long workspaceId,
+ UUID subgraphRootUuid,
+ Path subgraphRootPath,
+ int maxDepth ) {
+ assert entities != null;
+ assert subgraphRootUuid != null;
+ assert workspaceId != null;
+ assert maxDepth >= 0;
+ if (maxDepth == 0) maxDepth = Integer.MAX_VALUE;
+ final String subgraphRootUuidString = subgraphRootUuid.toString();
+ // Create a new subgraph query, and add a child for the root ...
+
+ SubgraphQueryEntity query = new SubgraphQueryEntity(workspaceId, subgraphRootUuidString);
+ entities.persist(query);
+ Long queryId = query.getId();
+
+ try {
+ // Insert a node for the root (this will be the starting point for the recursive operation) ...
+ SubgraphNodeEntity root = new SubgraphNodeEntity(queryId, subgraphRootUuidString, 0);
+ entities.persist(root);
+
+ // Now add the children by inserting the children, one level at a time.
+ // Note that we do this for the root, and for each level until 1 BEYOND
+ // the max depth (so that we can get the children for the nodes that are
+ // at the maximum depth)...
+ Query statement = entities.createNamedQuery("SubgraphNodeEntity.insertChildren");
+ int numChildrenInserted = 0;
+ int parentLevel = 0;
+ while (parentLevel <= maxDepth) {
+ // Insert the children of the next level by inserting via a select (join) of the children
+ statement.setParameter("queryId", queryId);
+ statement.setParameter("workspaceId", workspaceId);
+ statement.setParameter("parentDepth", parentLevel);
+ numChildrenInserted = statement.executeUpdate();
+ if (numChildrenInserted == 0) break;
+ parentLevel = parentLevel + 1;
+ }
+ } catch (RuntimeException t) {
+ // Clean up the search and results ...
+ try {
+ Query search = entities.createNamedQuery("SubgraphNodeEntity.deleteByQueryId");
+ search.setParameter("queryId", query.getId());
+ search.executeUpdate();
+ } finally {
+ entities.remove(query);
+ }
+ throw t;
+ }
+
+ return new SubgraphQuery(context, entities, workspaceId, query, subgraphRootPath, maxDepth);
+ }
+
+ // private final ExecutionContext context;
+ private final EntityManager manager;
+ private final Long workspaceId;
+ private SubgraphQueryEntity query;
+ private final int maxDepth;
+ private final Path subgraphRootPath;
+
+ protected SubgraphQuery( ExecutionContext context,
+ EntityManager manager,
+ Long workspaceId,
+ SubgraphQueryEntity query,
+ Path subgraphRootPath,
+ int maxDepth ) {
+ assert manager != null;
+ assert query != null;
+ assert context != null;
+ // assert subgraphRootPath != null;
+ assert workspaceId != null;
+ // this.context = context;
+ this.manager = manager;
+ this.workspaceId = workspaceId;
+ this.query = query;
+ this.maxDepth = maxDepth;
+ this.subgraphRootPath = subgraphRootPath;
+ }
+
+ /**
+ * @return maxDepth
+ */
+ public int getMaxDepth() {
+ return maxDepth;
+ }
+
+ /**
+ * @return manager
+ */
+ public EntityManager getEntityManager() {
+ return manager;
+ }
+
+ /**
+ * @return subgraphRootPath
+ */
+ public Path getSubgraphRootPath() {
+ return subgraphRootPath;
+ }
+
+ /**
+ * @return query
+ */
+ public SubgraphQueryEntity getSubgraphQueryEntity() {
+ if (query == null) throw new IllegalStateException();
+ return query;
+ }
+
+ public int getNodeCount( boolean includeRoot ) {
+ if (query == null) throw new IllegalStateException();
+ // Now query for all the nodes and put into a list ...
+ Query search = manager.createNamedQuery("SubgraphNodeEntity.getCount");
+ search.setParameter("queryId", query.getId());
+
+ // Now process the nodes below the subgraph's root ...
+ try {
+ return ((Long)search.getSingleResult()).intValue() - (includeRoot ? 0 : 1);
+ } catch (NoResultException e) {
+ return 0;
+ }
+ }
+
+ /**
+ * Get the {@link NodeEntity root node} of the subgraph. This must be called before the query is {@link #close() closed}.
+ *
+ * @return the subgraph's root nodes
+ */
+ public NodeEntity getNode() {
+ // Now query for all the nodes and put into a list ...
+ Query search = manager.createNamedQuery("SubgraphNodeEntity.getChildEntities");
+ search.setParameter("queryId", query.getId());
+ search.setParameter("workspaceId", workspaceId);
+ search.setParameter("depth", 0);
+ search.setParameter("maxDepth", 0);
+
+ // Now process the nodes below the subgraph's root ...
+ return (NodeEntity)search.getSingleResult();
+ }
+
+ /**
+ * Get the {@link NodeEntity nodes} in the subgraph. This must be called before the query is {@link #close() closed}.
+ *
+ * @param includeRoot true if the subgraph's root node is to be included, or false otherwise
+ * @param includeChildrenOfMaxDepthNodes true if the method is to include nodes that are children of nodes that are at the
+ * maximum depth, or false if only nodes up to the maximum depth are to be included
+ * @return the list of nodes, in breadth-first order
+ */
+ @SuppressWarnings( "unchecked" )
+ public List getNodes( boolean includeRoot,
+ boolean includeChildrenOfMaxDepthNodes ) {
+ if (query == null) throw new IllegalStateException();
+ // Now query for all the nodes and put into a list ...
+ Query search = manager.createNamedQuery("SubgraphNodeEntity.getChildEntities");
+ search.setParameter("queryId", query.getId());
+ search.setParameter("workspaceId", workspaceId);
+ search.setParameter("depth", includeRoot ? 0 : 1);
+ search.setParameter("maxDepth", includeChildrenOfMaxDepthNodes ? maxDepth : maxDepth - 1);
+
+ // Now process the nodes below the subgraph's root ...
+ return search.getResultList();
+ }
+
+ /**
+ * Get the {@link Location} for each of the nodes in the subgraph. This must be called before the query is {@link #close()
+ * closed}.
+ *
+ * This method calls {@link #getNodes(boolean,boolean)}. Therefore, calling {@link #getNodes(boolean,boolean)} and this method
+ * for the same subgraph is not efficient; consider just calling {@link #getNodes(boolean,boolean)} alone.
+ *
+ *
+ * @param includeRoot true if the properties for the subgraph's root node are to be included, or false otherwise
+ * @param includeChildrenOfMaxDepthNodes true if the method is to include nodes that are children of nodes that are at the
+ * maximum depth, or false if only nodes up to the maximum depth are to be included
+ * @return the list of {@link Location locations}, one for each of the nodes in the subgraph, in breadth-first order
+ */
+ // public List getNodeLocations( boolean includeRoot,
+ // boolean includeChildrenOfMaxDepthNodes ) {
+ // if (query == null) throw new IllegalStateException();
+ // // Set up a map of the paths to the nodes, keyed by UUIDs. This saves us from having to build
+ // // the paths every time ...
+ // Map pathByUuid = new HashMap();
+ // LinkedList locations = new LinkedList();
+ // String subgraphRootUuid = query.getRootUuid();
+ // pathByUuid.put(subgraphRootUuid, subgraphRootPath);
+ // UUID uuid = UUID.fromString(subgraphRootUuid);
+ // if (includeRoot) {
+ // locations.add(Location.create(subgraphRootPath, uuid));
+ // }
+ //
+ // // Now iterate over the child nodes in the subgraph (we've already included the root) ...
+ // final PathFactory pathFactory = context.getValueFactories().getPathFactory();
+ // final NameFactory nameFactory = context.getValueFactories().getNameFactory();
+ // for (ChildEntity entity : getNodes(false, includeChildrenOfMaxDepthNodes)) {
+ // String parentUuid = entity.getParentUuidString();
+ // Path parentPath = pathByUuid.get(parentUuid);
+ // assert parentPath != null;
+ // String nsUri = entity.getChildNamespace().getUri();
+ // String localName = entity.getChildName();
+ // int sns = entity.getSameNameSiblingIndex();
+ // Name childName = nameFactory.create(nsUri, localName);
+ // Path childPath = pathFactory.create(parentPath, childName, sns);
+ // String childUuid = entity.getId().getChildUuidString();
+ // pathByUuid.put(childUuid, childPath);
+ // uuid = UUID.fromString(childUuid);
+ // locations.add(Location.create(childPath, uuid));
+ //
+ // }
+ // return locations;
+ // }
+
+ /**
+ * Get the list of references that are owned by nodes within the subgraph and that point to other nodes in this same
+ * subgraph. This set of references is important in copying a subgraph, since all intra-subgraph references in the
+ * original subgraph must also be intra-subgraph references in the copy.
+ *
+ * @return the list of references completely contained by this subgraphs
+ */
+ @SuppressWarnings( "unchecked" )
+ public List getInternalReferences() {
+ Query references = manager.createNamedQuery("SubgraphNodeEntity.getInternalReferences");
+ references.setParameter("queryId", query.getId());
+ references.setParameter("workspaceId", workspaceId);
+ return references.getResultList();
+ }
+
+ /**
+ * Get the list of references that are owned by nodes within the subgraph and that point to nodes not in this same
+ * subgraph. This set of references is important in copying a subgraph.
+ *
+ * @return the list of references that are owned by the subgraph but that point to nodes outside of the subgraph
+ */
+ @SuppressWarnings( "unchecked" )
+ public List getOutwardReferences() {
+ Query references = manager.createNamedQuery("SubgraphNodeEntity.getOutwardReferences");
+ references.setParameter("queryId", query.getId());
+ references.setParameter("workspaceId", workspaceId);
+ return references.getResultList();
+ }
+
+ /**
+ * Get the list of references that are owned by nodes outside of the subgraph that point to nodes in this
+ * subgraph. This set of references is important in deleting nodes, since such references prevent the deletion of the
+ * subgraph.
+ *
+ * @return the list of references that are no longer valid
+ */
+ @SuppressWarnings( "unchecked" )
+ public List getInwardReferences() {
+ // Verify referential integrity: that none of the deleted nodes are referenced by nodes not being deleted.
+ Query references = manager.createNamedQuery("SubgraphNodeEntity.getInwardReferences");
+ references.setParameter("queryId", query.getId());
+ references.setParameter("workspaceId", workspaceId);
+ return references.getResultList();
+ }
+
+ /**
+ * Delete the nodes in the subgraph. This method first does not check for referential integrity (see
+ * {@link #getInwardReferences()}).
+ *
+ * @param includeRoot true if the root node should also be deleted
+ */
+ @SuppressWarnings( "unchecked" )
+ public void deleteSubgraph( boolean includeRoot ) {
+ if (query == null) throw new IllegalStateException();
+
+ List nodes = getNodes(true, true);
+ List uuids = new ArrayList(nodes.size());
+ for (NodeEntity node : nodes) {
+ uuids.add(node.getNodeUuidString());
+ }
+
+ // Delete the LargeValueEntities ...
+ Query withLargeValues = manager.createNamedQuery("SubgraphNodeEntity.getNodeEntitiesWithLargeValues");
+ withLargeValues.setParameter("queryId", query.getId());
+ withLargeValues.setParameter("depth", includeRoot ? 0 : 1);
+ withLargeValues.setParameter("workspaceId", workspaceId);
+ List nodesWithLargeValues = withLargeValues.getResultList();
+ if (nodesWithLargeValues.size() != 0) {
+ for (NodeEntity node : nodesWithLargeValues) {
+ node.getLargeValues().clear();
+ }
+ manager.flush();
+ }
+
+ // Delete the ChildEntities ...
+ Query delete = manager.createNamedQuery("SubgraphNodeEntity.clearParentReferences");
+ delete.setParameter("queryId", query.getId());
+ delete.setParameter("depth", includeRoot ? 0 : 1);
+ delete.setParameter("workspaceId", workspaceId);
+ delete.executeUpdate();
+
+ delete = manager.createNamedQuery("SubgraphNodeEntity.deleteChildEntities");
+ delete.setParameter("queryId", query.getId());
+ delete.setParameter("depth", includeRoot ? 0 : 1);
+ delete.setParameter("workspaceId", workspaceId);
+ delete.executeUpdate();
+
+ // Delete references ...
+ // delete = manager.createNamedQuery("SubgraphNodeEntity.deleteReferences");
+ // delete.setParameter("queryId", query.getId());
+ // delete.setParameter("depth", includeRoot ? 0 : 1);
+ // delete.setParameter("workspaceId", workspaceId);
+ // delete.executeUpdate();
+
+ // Delete unused large values ...
+ LargeValueEntity.deleteUnused(manager);
+
+ manager.flush();
+ }
+
+ /**
+ * Close this query object and clean up all in-database records associated with this query. This method must be called
+ * when this query is no longer needed, and once it is called, this subgraph query is no longer usable.
+ */
+ public void close() {
+ if (query == null) return;
+ // Clean up the search and results ...
+ try {
+ Query search = manager.createNamedQuery("SubgraphNodeEntity.deleteByQueryId");
+ search.setParameter("queryId", query.getId());
+ search.executeUpdate();
+ } finally {
+ try {
+ manager.remove(query);
+ } finally {
+ query = null;
+ }
+ }
+ }
+}
Property changes on: extensions\dna-connector-store-jpa\src\main\java\org\jboss\dna\connector\store\jpa\model\simple\SubgraphQuery.java
___________________________________________________________________
Added: svn:keywords
+ Id Revision
Added: svn:eol-style
+ LF
Index: extensions/dna-connector-store-jpa/src/main/java/org/jboss/dna/connector/store/jpa/model/simple/SubgraphQueryEntity.java
===================================================================
--- extensions/dna-connector-store-jpa/src/main/java/org/jboss/dna/connector/store/jpa/model/simple/SubgraphQueryEntity.java (revision 0)
+++ extensions/dna-connector-store-jpa/src/main/java/org/jboss/dna/connector/store/jpa/model/simple/SubgraphQueryEntity.java (revision 0)
@@ -0,0 +1,75 @@
+/*
+ * JBoss DNA (http://www.jboss.org/dna)
+ * See the COPYRIGHT.txt file distributed with this work for information
+ * regarding copyright ownership. Some portions may be licensed
+ * to Red Hat, Inc. under one or more contributor license agreements.
+ * See the AUTHORS.txt file in the distribution for a full listing of
+ * individual contributors.
+ *
+ * JBoss DNA is free software. Unless otherwise indicated, all code in JBoss DNA
+ * is licensed to you under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * JBoss DNA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.dna.connector.store.jpa.model.simple;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+
+/**
+ * Represents a temporary working area for a query that retrieves the nodes in a subgraph.
+ */
+@Entity( name = "DNA_SUBGRAPH_QUERIES" )
+public class SubgraphQueryEntity {
+
+ @Id
+ @GeneratedValue( strategy = GenerationType.AUTO )
+ @Column( name = "ID", updatable = false )
+ private Long id;
+
+ @Column( name = "WORKSPACE_ID", nullable = false )
+ private Long workspaceId;
+
+ @Column( name = "ROOT_UUID", updatable = false, nullable = false, length = 36 )
+ private String rootUuid;
+
+ public SubgraphQueryEntity( Long workspaceId,
+ String rootUuid ) {
+ this.rootUuid = rootUuid;
+ this.workspaceId = workspaceId;
+ }
+
+ /**
+ * @return id
+ */
+ public Long getId() {
+ return id;
+ }
+
+ /**
+ * @return rootUuid
+ */
+ public String getRootUuid() {
+ return rootUuid;
+ }
+
+ /**
+ * @return workspaceId
+ */
+ public Long getWorkspaceId() {
+ return workspaceId;
+ }
+}
Property changes on: extensions\dna-connector-store-jpa\src\main\java\org\jboss\dna\connector\store\jpa\model\simple\SubgraphQueryEntity.java
___________________________________________________________________
Added: svn:keywords
+ Id Revision
Added: svn:eol-style
+ LF
Index: extensions/dna-connector-store-jpa/src/main/java/org/jboss/dna/connector/store/jpa/util/Serializer.java
===================================================================
--- extensions/dna-connector-store-jpa/src/main/java/org/jboss/dna/connector/store/jpa/util/Serializer.java (revision 1382)
+++ extensions/dna-connector-store-jpa/src/main/java/org/jboss/dna/connector/store/jpa/util/Serializer.java (working copy)
@@ -786,7 +786,7 @@
// Read the length of the content ...
long binaryLength = stream.readLong();
byte[] content = new byte[(int)binaryLength];
- stream.read(content);
+ stream.readFully(content, 0, content.length);
if (!skip) {
value = valueFactories.getBinaryFactory().create(content);
}
@@ -796,7 +796,7 @@
// Read the hash ...
int hashLength = stream.readInt();
byte[] hash = new byte[hashLength];
- stream.read(hash);
+ stream.readFully(hash, 0, hashLength);
// Read the length of the content ...
long length = stream.readLong();
if (skip) {
Index: extensions/dna-connector-store-jpa/src/main/resources/org/jboss/dna/connector/store/jpa/JpaConnectorI18n.properties
===================================================================
--- extensions/dna-connector-store-jpa/src/main/resources/org/jboss/dna/connector/store/jpa/JpaConnectorI18n.properties (revision 1382)
+++ extensions/dna-connector-store-jpa/src/main/resources/org/jboss/dna/connector/store/jpa/JpaConnectorI18n.properties (working copy)
@@ -43,3 +43,4 @@
connectionIsNoLongerOpen = This connection for source {0} has already been closed
basicModelDescription = Database model that stores node properties as opaque records and children as transparent records. Large property values are stored separately.
+simpleModelDescription = Database model that stores nodes (transparently) and their properties (opaquely) in the same row. Large property values are stored separately.
Index: extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/JpaConnectorCreateWorkspacesTest.java
===================================================================
--- extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/JpaConnectorCreateWorkspacesTest.java (revision 1382)
+++ extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/JpaConnectorCreateWorkspacesTest.java (working copy)
@@ -30,7 +30,6 @@
import org.jboss.dna.common.statistic.Stopwatch;
import org.jboss.dna.graph.Graph;
import org.jboss.dna.graph.Workspace;
-import org.jboss.dna.graph.connector.RepositorySource;
import org.jboss.dna.graph.connector.test.WorkspaceConnectorTest;
import org.junit.Test;
@@ -38,32 +37,13 @@
* These tests verify that the JPA connector behaves correctly when the source is configured to
* {@link JpaSource#setCreatingWorkspacesAllowed(boolean) allow the creation of workspaces}.
*/
-public class JpaConnectorCreateWorkspacesTest extends WorkspaceConnectorTest {
+public abstract class JpaConnectorCreateWorkspacesTest extends WorkspaceConnectorTest {
- private String[] predefinedWorkspaces;
+ protected String[] predefinedWorkspaces;
/**
* {@inheritDoc}
*
- * @see org.jboss.dna.graph.connector.test.AbstractConnectorTest#setUpSource()
- */
- @Override
- protected RepositorySource setUpSource() {
- predefinedWorkspaces = new String[] {"workspace1", "workspace1a"};
-
- // Set the connection properties using the environment defined in the POM files ...
- JpaSource source = TestEnvironment.configureJpaSource("Test Repository", this);
-
- // Override the inherited properties, since that's the focus of these tests ...
- source.setCreatingWorkspacesAllowed(true);
- source.setPredefinedWorkspaceNames(predefinedWorkspaces);
-
- return source;
- }
-
- /**
- * {@inheritDoc}
- *
* @see org.jboss.dna.graph.connector.test.AbstractConnectorTest#initializeContent(org.jboss.dna.graph.Graph)
*/
@Override
Index: extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/JpaConnectorNoCreateWorkspaceTest.java
===================================================================
--- extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/JpaConnectorNoCreateWorkspaceTest.java (revision 1382)
+++ extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/JpaConnectorNoCreateWorkspaceTest.java (working copy)
@@ -40,7 +40,7 @@
*/
public class JpaConnectorNoCreateWorkspaceTest extends WorkspaceConnectorTest {
- private String[] predefinedWorkspaces;
+ protected String[] predefinedWorkspaces;
/**
* {@inheritDoc}
Index: extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/model/basic/BasicCreateWorkspacesTest.java
===================================================================
--- extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/model/basic/BasicCreateWorkspacesTest.java (revision 0)
+++ extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/model/basic/BasicCreateWorkspacesTest.java (revision 0)
@@ -0,0 +1,24 @@
+package org.jboss.dna.connector.store.jpa.model.basic;
+
+import org.jboss.dna.connector.store.jpa.JpaConnectorCreateWorkspacesTest;
+import org.jboss.dna.connector.store.jpa.JpaSource;
+import org.jboss.dna.connector.store.jpa.TestEnvironment;
+import org.jboss.dna.graph.connector.RepositorySource;
+
+public class BasicCreateWorkspacesTest extends JpaConnectorCreateWorkspacesTest {
+
+ @Override
+ protected RepositorySource setUpSource() {
+ predefinedWorkspaces = new String[] {"workspace1", "workspace1a"};
+
+ // Set the connection properties using the environment defined in the POM files ...
+ JpaSource source = TestEnvironment.configureJpaSource("Test Repository", this);
+
+ // Override the inherited properties, since that's the focus of these tests ...
+ source.setCreatingWorkspacesAllowed(true);
+ source.setPredefinedWorkspaceNames(predefinedWorkspaces);
+
+ return source;
+ }
+
+}
Property changes on: extensions\dna-connector-store-jpa\src\test\java\org\jboss\dna\connector\store\jpa\model\basic\BasicCreateWorkspacesTest.java
___________________________________________________________________
Added: svn:keywords
+ Id Revision
Added: svn:eol-style
+ LF
Index: extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/model/basic/BasicNoCreateWorkspaceTest.java
===================================================================
--- extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/model/basic/BasicNoCreateWorkspaceTest.java (revision 0)
+++ extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/model/basic/BasicNoCreateWorkspaceTest.java (revision 0)
@@ -0,0 +1,23 @@
+package org.jboss.dna.connector.store.jpa.model.basic;
+
+import org.jboss.dna.connector.store.jpa.JpaConnectorNoCreateWorkspaceTest;
+import org.jboss.dna.connector.store.jpa.JpaSource;
+import org.jboss.dna.connector.store.jpa.TestEnvironment;
+import org.jboss.dna.graph.connector.RepositorySource;
+
+public class BasicNoCreateWorkspaceTest extends JpaConnectorNoCreateWorkspaceTest {
+
+ @Override
+ protected RepositorySource setUpSource() {
+ predefinedWorkspaces = new String[] {"workspace1", "workspace1a"};
+
+ // Set the connection properties using the environment defined in the POM files ...
+ JpaSource source = TestEnvironment.configureJpaSource("Test Repository", this);
+
+ // Override the inherited properties, since that's the focus of these tests ...
+ source.setCreatingWorkspacesAllowed(true);
+ source.setPredefinedWorkspaceNames(predefinedWorkspaces);
+
+ return source;
+ }
+}
Property changes on: extensions\dna-connector-store-jpa\src\test\java\org\jboss\dna\connector\store\jpa\model\basic\BasicNoCreateWorkspaceTest.java
___________________________________________________________________
Added: svn:keywords
+ Id Revision
Added: svn:eol-style
+ LF
Index: extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/model/simple/NodeEntityTest.java
===================================================================
--- extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/model/simple/NodeEntityTest.java (revision 0)
+++ extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/model/simple/NodeEntityTest.java (revision 0)
@@ -0,0 +1,168 @@
+package org.jboss.dna.connector.store.jpa.model.simple;
+
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsNull.notNullValue;
+import static org.junit.Assert.assertThat;
+import java.util.UUID;
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.Query;
+import org.hibernate.ejb.Ejb3Configuration;
+import org.jboss.dna.connector.store.jpa.model.common.NamespaceEntity;
+import org.jboss.dna.graph.ExecutionContext;
+import org.jboss.dna.graph.property.PropertyType;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+public class NodeEntityTest {
+
+ private static final Boolean SHOW_SQL = false;
+ private static final Boolean USE_CACHE = false;
+
+ private ExecutionContext context;
+ private EntityManagerFactory factory;
+ private EntityManager manager;
+ private SimpleModel model;
+
+ @Before
+ public void beforeEach() throws Exception {
+ model = new SimpleModel();
+
+ // Connect to the database ...
+ Ejb3Configuration configurator = new Ejb3Configuration();
+ model.configure(configurator);
+ configurator.setProperty("hibernate.dialect", "org.hibernate.dialect.HSQLDialect");
+ configurator.setProperty("hibernate.connection.driver_class", "org.hsqldb.jdbcDriver");
+ configurator.setProperty("hibernate.connection.username", "sa");
+ configurator.setProperty("hibernate.connection.password", "");
+ configurator.setProperty("hibernate.connection.url", "jdbc:hsqldb:mem:.");
+ configurator.setProperty("hibernate.show_sql", SHOW_SQL.toString());
+ configurator.setProperty("hibernate.format_sql", "true");
+ configurator.setProperty("hibernate.use_sql_comments", "true");
+ configurator.setProperty("hibernate.hbm2ddl.auto", "create");
+ if (USE_CACHE) {
+ configurator.setProperty("hibernate.cache.provider_class", "org.hibernate.cache.HashtableCacheProvider");
+
+ }
+
+ factory = configurator.buildEntityManagerFactory();
+ manager = factory.createEntityManager();
+ context = new ExecutionContext();
+ }
+
+ @After
+ public void afterEach() throws Exception {
+ try {
+ if (manager != null) manager.close();
+ } finally {
+ manager = null;
+ if (factory != null) {
+ try {
+ factory.close();
+ } finally {
+ factory = null;
+ }
+ }
+ }
+ }
+
+ @Test
+ public void shouldSaveAndReloadNode() {
+ String rootUuid = UUID.randomUUID().toString();
+ long workspaceId = 1L;
+
+ manager.getTransaction().begin();
+
+ NamespaceEntity namespace = new NamespaceEntity("");
+ manager.persist(namespace);
+
+ NodeEntity root = new NodeEntity(0, null, rootUuid, workspaceId, 1, namespace, "root");
+ LargeValueEntity largeValue = LargeValueEntity.create("This is a nonsense string that I am typing.".getBytes(),
+ PropertyType.STRING,
+ false);
+ root.getLargeValues().add(largeValue);
+ manager.persist(root);
+ manager.persist(largeValue);
+
+ final int NUM_CHILDREN = 10;
+ for (int i = 0; i < NUM_CHILDREN; i++) {
+ NodeEntity child = new NodeEntity(0, root, UUID.randomUUID().toString(), workspaceId, 1, namespace, "child" + i);
+ root.addChild(child);
+
+ manager.persist(child);
+ }
+
+
+ manager.getTransaction().commit();
+ manager.close();
+
+ manager = factory.createEntityManager();
+
+ Query query = manager.createNamedQuery("NodeEntity.findByNodeUuid");
+ query.setParameter("workspaceId", workspaceId);
+ query.setParameter("nodeUuidString", rootUuid);
+
+ NodeEntity newRoot = (NodeEntity)query.getSingleResult();
+ assertThat(newRoot, is(notNullValue()));
+ assertThat(newRoot, is(root));
+ assertThat(newRoot.getChildren().size(), is(NUM_CHILDREN));
+
+ for (int i = 0; i < NUM_CHILDREN; i++) {
+ assertThat(newRoot.getChildren().get(i).getChildName(), is("child" + i));
+ // NodeEntity child = newRoot.getChildren().get(i);
+ // System.out.println(child.getChildName() + " " + child.getIndexInParent());
+ }
+
+ root.getLargeValues().size();
+ }
+
+ @Test
+ public void shouldDeleteRecursively() {
+ String rootUuid = UUID.randomUUID().toString();
+ long workspaceId = 1L;
+
+ manager.getTransaction().begin();
+
+ NamespaceEntity namespace = new NamespaceEntity("");
+ manager.persist(namespace);
+
+ NodeEntity root = new NodeEntity(0, null, rootUuid, workspaceId, 1, namespace, "root");
+ manager.persist(root);
+
+ final int DEPTH = 10;
+ NodeEntity parent = root;
+
+ for (int i = 0; i < DEPTH; i++) {
+ NodeEntity child = new NodeEntity(0, parent, UUID.randomUUID().toString(), workspaceId, 1, namespace, "child" + i);
+ root.addChild(child);
+
+ manager.persist(child);
+ parent = child;
+ }
+
+ manager.getTransaction().commit();
+ manager.close();
+
+ manager = factory.createEntityManager();
+ manager.getTransaction().begin();
+
+ SubgraphQuery subgraph = SubgraphQuery.create(context,
+ manager,
+ workspaceId,
+ UUID.fromString(rootUuid),
+ context.getValueFactories().getPathFactory().createRootPath(),
+ 0);
+
+ assertThat(subgraph.getNodeCount(false), is(10));
+
+ subgraph.deleteSubgraph(true);
+ subgraph.close();
+
+ int count = (Integer)manager.createNativeQuery("SELECT count(*) FROM dna_simple_node").getSingleResult();
+ assertThat(count, is(0));
+
+ manager.getTransaction().commit();
+
+ }
+}
Property changes on: extensions\dna-connector-store-jpa\src\test\java\org\jboss\dna\connector\store\jpa\model\simple\NodeEntityTest.java
___________________________________________________________________
Added: svn:keywords
+ Id Revision
Added: svn:eol-style
+ LF
Index: extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/model/simple/SimpleCreateWorkspacesTest.java
===================================================================
--- extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/model/simple/SimpleCreateWorkspacesTest.java (revision 0)
+++ extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/model/simple/SimpleCreateWorkspacesTest.java (revision 0)
@@ -0,0 +1,31 @@
+package org.jboss.dna.connector.store.jpa.model.simple;
+
+import org.jboss.dna.connector.store.jpa.JpaConnectorCreateWorkspacesTest;
+import org.jboss.dna.connector.store.jpa.JpaSource;
+import org.jboss.dna.connector.store.jpa.TestEnvironment;
+import org.jboss.dna.graph.connector.RepositorySource;
+
+public class SimpleCreateWorkspacesTest extends JpaConnectorCreateWorkspacesTest {
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see org.jboss.dna.graph.connector.test.AbstractConnectorTest#setUpSource()
+ */
+ @Override
+ protected RepositorySource setUpSource() {
+ predefinedWorkspaces = new String[] {"workspace1", "workspace1a"};
+
+ // Set the connection properties using the environment defined in the POM files ...
+ JpaSource source = TestEnvironment.configureJpaSource("Test Repository", this);
+ source.setModel(JpaSource.Models.SIMPLE.getName());
+
+ // Override the inherited properties, since that's the focus of these tests ...
+ source.setCreatingWorkspacesAllowed(true);
+ source.setPredefinedWorkspaceNames(predefinedWorkspaces);
+ source.setDefaultWorkspaceName(predefinedWorkspaces[0]);
+
+ return source;
+ }
+
+}
Property changes on: extensions\dna-connector-store-jpa\src\test\java\org\jboss\dna\connector\store\jpa\model\simple\SimpleCreateWorkspacesTest.java
___________________________________________________________________
Added: svn:keywords
+ Id Revision
Added: svn:eol-style
+ LF
Index: extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/model/simple/SimpleJpaConnectorReadableTest.java
===================================================================
--- extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/model/simple/SimpleJpaConnectorReadableTest.java (revision 0)
+++ extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/model/simple/SimpleJpaConnectorReadableTest.java (revision 0)
@@ -0,0 +1,81 @@
+package org.jboss.dna.connector.store.jpa.model.simple;
+
+import org.jboss.dna.common.statistic.Stopwatch;
+import org.jboss.dna.connector.store.jpa.JpaSource;
+import org.jboss.dna.graph.ExecutionContext;
+import org.jboss.dna.graph.Graph;
+import org.jboss.dna.graph.Subgraph;
+import org.jboss.dna.graph.connector.RepositoryConnectionFactory;
+import org.jboss.dna.graph.connector.RepositoryContext;
+import org.jboss.dna.graph.connector.RepositorySource;
+import org.jboss.dna.graph.connector.test.ReadableConnectorTest;
+import org.jboss.dna.graph.observe.Observer;
+
+public class SimpleJpaConnectorReadableTest extends ReadableConnectorTest {
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see org.jboss.dna.graph.connector.test.AbstractConnectorTest#setUpSource()
+ */
+ @Override
+ protected RepositorySource setUpSource() {
+ // Set the connection properties using the environment defined in the POM files ...
+ JpaSource source = new JpaSource();
+
+ source.setModel(JpaSource.Models.SIMPLE.getName());
+ source.setName("SimpleJpaSource");
+ source.setDialect("org.hibernate.dialect.HSQLDialect");
+ source.setDriverClassName("org.hsqldb.jdbcDriver");
+ source.setUsername("sa");
+ source.setPassword("");
+ source.setUrl("jdbc:hsqldb:mem:test");
+ source.setShowSql(false);
+ source.setAutoGenerateSchema("create");
+
+ source.initialize(new RepositoryContext() {
+
+ private final ExecutionContext context = new ExecutionContext();
+
+ public Subgraph getConfiguration( int depth ) {
+ return null;
+ }
+
+ public ExecutionContext getExecutionContext() {
+ return context;
+ }
+
+ public Observer getObserver() {
+ return null;
+ }
+
+ public RepositoryConnectionFactory getRepositoryConnectionFactory() {
+ return null;
+ }
+
+ });
+
+ return source;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see org.jboss.dna.graph.connector.test.AbstractConnectorTest#initializeContent(org.jboss.dna.graph.Graph)
+ */
+ @Override
+ protected void initializeContent( Graph graph ) {
+ String initialPath = "";
+ int depth = 4;
+ int numChildrenPerNode = 4;
+ int numPropertiesPerNode = 7;
+ Stopwatch sw = new Stopwatch();
+ boolean batch = true;
+ // graph.createWorkspace().named("default");
+ createSubgraph(graph, initialPath, depth, numChildrenPerNode, numPropertiesPerNode, batch, sw, System.out, null);
+ graph.createWorkspace().named("other workspace");
+ createSubgraph(graph, initialPath, depth, numChildrenPerNode, numPropertiesPerNode, batch, sw, System.out, null);
+ graph.useWorkspace("default");
+ }
+
+}
Property changes on: extensions\dna-connector-store-jpa\src\test\java\org\jboss\dna\connector\store\jpa\model\simple\SimpleJpaConnectorReadableTest.java
___________________________________________________________________
Added: svn:keywords
+ Id Revision
Added: svn:eol-style
+ LF
Index: extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/model/simple/SimpleJpaConnectorWritableTest.java
===================================================================
--- extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/model/simple/SimpleJpaConnectorWritableTest.java (revision 0)
+++ extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/model/simple/SimpleJpaConnectorWritableTest.java (revision 0)
@@ -0,0 +1,74 @@
+package org.jboss.dna.connector.store.jpa.model.simple;
+
+import org.jboss.dna.connector.store.jpa.JpaSource;
+import org.jboss.dna.graph.ExecutionContext;
+import org.jboss.dna.graph.Graph;
+import org.jboss.dna.graph.Subgraph;
+import org.jboss.dna.graph.connector.RepositoryConnectionFactory;
+import org.jboss.dna.graph.connector.RepositoryContext;
+import org.jboss.dna.graph.connector.RepositorySource;
+import org.jboss.dna.graph.connector.test.WritableConnectorTest;
+import org.jboss.dna.graph.observe.Observer;
+
+public class SimpleJpaConnectorWritableTest extends WritableConnectorTest {
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see org.jboss.dna.graph.connector.test.AbstractConnectorTest#setUpSource()
+ */
+ @Override
+ protected RepositorySource setUpSource() {
+ // Set the connection properties using the environment defined in the POM files ...
+ JpaSource source = new JpaSource();
+
+ source.setModel(JpaSource.Models.SIMPLE.getName());
+ source.setName("SimpleJpaSource");
+ source.setDialect("org.hibernate.dialect.HSQLDialect");
+ source.setDriverClassName("org.hsqldb.jdbcDriver");
+ source.setUsername("sa");
+ source.setPassword("");
+ source.setUrl("jdbc:hsqldb:mem:test");
+ source.setShowSql(false);
+ source.setAutoGenerateSchema("create");
+
+ source.initialize(new RepositoryContext() {
+
+ private final ExecutionContext context = new ExecutionContext();
+
+ public Subgraph getConfiguration( int depth ) {
+ return null;
+ }
+
+ public ExecutionContext getExecutionContext() {
+ return context;
+ }
+
+ public Observer getObserver() {
+ return null;
+ }
+
+ public RepositoryConnectionFactory getRepositoryConnectionFactory() {
+ return null;
+ }
+
+ });
+
+ return source;
+ }
+
+ @Override
+ public void shouldCopyNodeWithChildren() {
+
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see org.jboss.dna.graph.connector.test.AbstractConnectorTest#initializeContent(org.jboss.dna.graph.Graph)
+ */
+ @Override
+ protected void initializeContent( Graph graph ) {
+ }
+
+}
Property changes on: extensions\dna-connector-store-jpa\src\test\java\org\jboss\dna\connector\store\jpa\model\simple\SimpleJpaConnectorWritableTest.java
___________________________________________________________________
Added: svn:keywords
+ Id Revision
Added: svn:eol-style
+ LF
Index: extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/model/simple/SimpleJpaSourceTest.java
===================================================================
--- extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/model/simple/SimpleJpaSourceTest.java (revision 0)
+++ extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/model/simple/SimpleJpaSourceTest.java (revision 0)
@@ -0,0 +1,62 @@
+package org.jboss.dna.connector.store.jpa.model.simple;
+
+import java.util.concurrent.TimeUnit;
+import org.jboss.dna.connector.store.jpa.JpaSource;
+import org.jboss.dna.graph.ExecutionContext;
+import org.jboss.dna.graph.Subgraph;
+import org.jboss.dna.graph.connector.RepositoryConnection;
+import org.jboss.dna.graph.connector.RepositoryConnectionFactory;
+import org.jboss.dna.graph.connector.RepositoryContext;
+import org.jboss.dna.graph.observe.Observer;
+import org.junit.Before;
+import org.junit.Test;
+
+public class SimpleJpaSourceTest {
+
+ private JpaSource source;
+
+ @Before
+ public void beforeEach() {
+ // Set the connection properties using the environment defined in the POM files ...
+ source = new JpaSource();
+
+ source.setModel(JpaSource.Models.SIMPLE.getName());
+ source.setName("SimpleJpaSource");
+ source.setDialect("org.hibernate.dialect.HSQLDialect");
+ source.setDriverClassName("org.hsqldb.jdbcDriver");
+ source.setUsername("sa");
+ source.setPassword("");
+ source.setUrl("jdbc:hsqldb:.");
+ source.setShowSql(true);
+ source.setAutoGenerateSchema("create");
+
+ source.initialize(new RepositoryContext() {
+
+ private final ExecutionContext context = new ExecutionContext();
+
+ public Subgraph getConfiguration( int depth ) {
+ return null;
+ }
+
+ public ExecutionContext getExecutionContext() {
+ return context;
+ }
+
+ public Observer getObserver() {
+ return null;
+ }
+
+ public RepositoryConnectionFactory getRepositoryConnectionFactory() {
+ return null;
+ }
+
+ });
+ }
+
+ @Test
+ public void shouldCreateLiveConnection() throws InterruptedException {
+ RepositoryConnection connection = source.getConnection();
+ connection.ping(1, TimeUnit.SECONDS);
+ connection.close();
+ }
+}
Property changes on: extensions\dna-connector-store-jpa\src\test\java\org\jboss\dna\connector\store\jpa\model\simple\SimpleJpaSourceTest.java
___________________________________________________________________
Added: svn:keywords
+ Id Revision
Added: svn:eol-style
+ LF
Index: extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/model/simple/SimpleNoCreateWorkspaceTest.java
===================================================================
--- extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/model/simple/SimpleNoCreateWorkspaceTest.java (revision 0)
+++ extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/model/simple/SimpleNoCreateWorkspaceTest.java (revision 0)
@@ -0,0 +1,30 @@
+package org.jboss.dna.connector.store.jpa.model.simple;
+
+import org.jboss.dna.connector.store.jpa.JpaConnectorNoCreateWorkspaceTest;
+import org.jboss.dna.connector.store.jpa.JpaSource;
+import org.jboss.dna.connector.store.jpa.TestEnvironment;
+import org.jboss.dna.graph.connector.RepositorySource;
+
+public class SimpleNoCreateWorkspaceTest extends JpaConnectorNoCreateWorkspaceTest {
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see org.jboss.dna.graph.connector.test.AbstractConnectorTest#setUpSource()
+ */
+ @Override
+ protected RepositorySource setUpSource() {
+ predefinedWorkspaces = new String[] {"workspace1", "workspace1a"};
+
+ // Set the connection properties using the environment defined in the POM files ...
+ JpaSource source = TestEnvironment.configureJpaSource("Test Repository", this);
+ source.setModel(JpaSource.Models.SIMPLE.getName());
+
+ // Override the inherited properties, since that's the focus of these tests ...
+ source.setCreatingWorkspacesAllowed(true);
+ source.setPredefinedWorkspaceNames(predefinedWorkspaces);
+ source.setDefaultWorkspaceName(predefinedWorkspaces[0]);
+
+ return source;
+ }
+}
Property changes on: extensions\dna-connector-store-jpa\src\test\java\org\jboss\dna\connector\store\jpa\model\simple\SimpleNoCreateWorkspaceTest.java
___________________________________________________________________
Added: svn:keywords
+ Id Revision
Added: svn:eol-style
+ LF
Index: extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/TestEnvironment.java
===================================================================
--- extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/TestEnvironment.java (revision 1382)
+++ extensions/dna-connector-store-jpa/src/test/java/org/jboss/dna/connector/store/jpa/TestEnvironment.java (working copy)
@@ -31,7 +31,7 @@
public static JpaSource configureJpaSource( String sourceName,
Object testCase ) {
Properties properties = new Properties();
- ClassLoader loader = testCase instanceof Class ? ((Class)testCase).getClassLoader() : testCase.getClass()
+ ClassLoader loader = testCase instanceof Class ? ((Class)testCase).getClassLoader() : testCase.getClass()
.getClassLoader();
try {
properties.load(loader.getResourceAsStream("database.properties"));