Internal Website Search

101-150 of 183 results

Complex Schema Upgrade not working

looked like this: class contact.Contact class customer.Customer extends contact.Contact class member . Member extends customer.Customer We have database records within each class type (Contact, Customer and Member ). Our new hierarchy looks like that: - The package " member " has been renamed to package

Composite indexes

(...) }   Here are my questions regarding composite indexes : #1. First of all - the first member in ... , then "room" which has 7-8 unique values etc...) #2. Can I use the same field as secondary member in many @Indexes? Something like that : @Index( members = { "lastModificationDate", "isPublished" }) @Index

com.objectdb.o.NLV cannot be cast to com.objectdb.o.CMV

the exact cause. support Support The mapFormCli filed is a member of a number of composite indices ... ( members ={"mapToCli", "mapFromCli"}),     @Index( members ={"mapToCli", "mapFromCli", "callDirection"}),     @Index( members ={"startDate", "mapToCli", "mapFromCli"}),  

First query takes 4+ minutes to complete

class in the DB. The class has data members that are basic Java types. Here is extract of the code ... ({ : // Indices building trees in client applications @Index( members ={"startDate", "toExtension"}), @Index( members ={"startDate", "fromExtension"}) }) public class RecordingMetaData { private Long id; 

Date field Index is corrupted due to time change

;   @Index( members ={"startDate", "startTime", "channelNumber"}),         @Index( members ={"startDate"}),         @Index( members ={"startTime"}),         @Index( members ={"startDate", "mapToCli

"where in" query

- and the MEMBER OF operator doesn't seem to do what I want (although I may be using it incorrectly ... is in subqueries). The following code demonstrates how to use MEMBER OF with parameter for this purpose ... ;     "SELECT e.name FROM MyEntity e WHERE e.name MEMBER OF :names");   

possible index required for improving query performance

Hi, I have the following entity class: @Entity @Table @Indices({ @Index( members ={"relationshipType", "party"}), @Index( members ={"relationshipType", "otherParty"}), @Index( members ={"relationshipType ... RelationshipType { PARENT, OWNER, ADMIN, CONTAINS, MEMBER , EMPLOYEE, MANAGER } private BaseObject party

java.lang.NullPointerException when using ORDER BY

is also a Date member like r.startDateTime.   prolancer Emil Andonov As I was writing the previous ... the problem if a run a query where the ORDER BY filed is not a member of any index. It just happens that startDateTime is not a member of any index while startDate, callDirection and mapToCli are members

Strange behaviour with ORDER BY and IN

if we order by a simple member (e.g. a String) being the Entity-ID and, at the same time, filter on this member with a simple IN-clause. Filtering with IN-clause or ordering on another member (which is not ... both are done on the ID member .   Assuming this simple Entity class: @Entity public class Location

JPA query of a Set of terms

WHERE si.term MEMBER OF :terms",     Page.class); query.setParameter("terms", terms ... = em.createQuery( "SELECT DISTINCT p FROM Page p " + "WHERE :t1 MEMBER OF p.terms AND :t2 MEMBER OF p

Query to search for common elements in two separate collections.

I'm trying to work out the most efficient way to build a query that can compare two collections for identical members . Something like: SELECT o FROM Object o WHERE o.someCollection CONTAINS MEMBER ... . This is easier and supported by JPA: SELECT o FROM MyClass o JOIN o.someCollection e WHERE e MEMBER

Error during cascaded merge

back. Here are the relevant parts of the involved Entity classes: @Entity @Indices({     @Index( members = {"lastPosition.receiveTime"}),     @Index( members = {"lastMovingPosition.receiveTime ... ;    return channelConfigurationSets;     } ... } @Entity @Index( members

Multi part paths in a composite index must have the same length

( members ={"tStamp.value", "instrumentId"}) public class OBN implements Serializable{     ... index definition is invalid: @Entity @Index( members ={"lastName", "address.city"}) // INVALID public ... ;  @Entity     @Index( members ={"tStamp.value", "instrumentId"})    

composite index not used in query

we defined a composite index for class Action: @Index(name="ssst", members ={"startDate","state ... the composite index: @Index(name="ssst", members ={"state","subType","type", "startDate"}) or any ... less useful, unless  startDate is last. support Support the sequence of the index members is the key, thanks hgzwicker Hans-Georg Zwicker

How to apply Unique constraints on embedded fields?

A . Something like: @Entity @Unique( members ={"b.c.values"}) @Entity public class A {     private B b ... . but my requirement is something like this @Entity @Unique( members = { "b1.c.values", "b2.c.values ... These are my sample classes. @Entity @Unique( members = { "b1.c.values", "b2.c.values" }) public class

Query over the keySet of a map field with collection parameter

" + EntityParent.class.getName() + " e " + "WHERE e.map member of ?1"; TypedQuery q = em.createQuery(query ... .value member of ?1 support Support I know this solution and this would also be also my first solution ... WHERE key member of ?1 Set params = new HashSet ( ) ; params . add ( "c2" ) ; q . setParameter ( 1 , params

query hint

none of these indices is in the log:   @Indices({  @Index(name="ctso", members ={"classIdentifier","type","state","objectNameUpper"}), @Index(name="lctso", members ={"linkedObjects.classIdentifier","linkedObjects.type","linkedObjects.state","linkedObjects.objectNameUpper"}), @Index(name="ln", members

New to Product & Having An Issue

;  I have a domain object class Called Department, which has a member of type DomainId.  DomainId has two member fields:  String accountId and String objectId.  The following code

can removing an entity throw an exception if the entity is in use?

A a, B b WHERE a = b.a OR a MEMBER OF b.list ... The query will have to be adjusted to your specific ... : SELECT DISTINCT b FROM B b WHERE :a = b.a OR :a MEMBER OF b.list ...   support Support

Searching lists within objects

attributeList = new ArrayList (); } @Entity @Unique( members ={"type","value"}) class Attribute {   ... enum (more efficient). An alternative solution is to use embedded objects: @Entity @Index( members

Failing to read entities under load in multithreaded tests

@Indices({ @Index( members ={"oidId", "type"}), @Index( members ={"parentAcl"}) }) public class TestEntity

LEFT JOIN FETCH over empty embedded collection returns no results

First of all, thank you for promptly implementing JOIN FETCH over nested paths in response to my inquiry a few months ago. However, I have run into one problem: if an embedded collection is empty, but I attempt to LEFT JOIN FETCH all the members of a collection within a (non-existent) member

100% CPU when using multiple BETWEEN

Hi, we are evaluating ObjectDB 2.5.1_03 in embedded mode. We have a DB of about 2800 instances of a class that has two java.lang.String members : toExtension and fromExtension. There are other members in the class, but not relevant to the problem.   A query like this causes the java process

Internationalization

be necessary, instead we could use maps for the international members and provide a map entry for each ... -language members where for example the long description would be even stored as a rather long HTML code

Problem witch CriteriaBuilder isMember(..)

_08 which fixes an issue of using MEMBER with embedded objects. support Support great, it works ... has different members , but the same size.  List uid1_list = .. new Testclass(1,1), new Testclass(2,1

Failed to write the value of field using reflection (error 363) on LAZY fetch

Hi There I am using ObjectDB 2.6.3. I get the following Exception when I try to read my entities with a query where I have set to use LAZY initalization. It fails when it tries to set a 1:n member ... hints? The Mapping of class Modell and its member : @Entity class Modell { ... @OneToMany(fetch

Exception after update of indices of Entity class

( members = {"recurrence.recurringEvent"}),     @Index ( members = {"relations.related

Executing JUnit "all tests" throws "Object ... belongs to another EntityManager" Exception

the  Symbol class, which has a private non-static member named string but a few static members

Navigation and Parameters

Greetings ObjectDB team, Suppose I pass a List of persistent objects to some query as a parameter, can I navigate to those objects' fields ? E.g.: SELECT x FROM ClassX x WHERE x.a IS MEMBER OF :y.b Thank You ! geekox86 Mohannad AlAwad You cannot navigate from a collection of objects

Problem with @UniqueConstraint

/java/jpa/entity/index For example: @Unique ( members ={"lastName","firstName"}) And for a single

c.o.jpa.type.EntityTypeImpl.getIdType() returns null

the debugger is i can see this member m_idType is null type EntityTypeImpl   (id=57) m_attrMap

can not use spring-data-jpa repository with NamedQuery

in spring-data-jpa named queries are used to implement repository interface methods, see http://static.springsource.org/spring-data/data-jpa/docs/current/reference/html/#jpa.query-methods.named-queries for example @NamedQuery(name = "Foo.findByBar", query = "select f from Foo f where :bar member

collection of embedded objects

and includes both the entity class field and the embedded class field, e.g.: @Entity @Index( members

Unexpected query token - AS

WHERE ( artifactActivatedGoals MEMBER OF ?1 OR artifactActivatedAssumptions MEMBER OF ?1 OR artifactActivatedCalibrations MEMBER OF ?1 ) AND artifact MEMBER OF instanceEntryArtifactSet.artifacts  

Problem using "and" for joined entities and indexed fields

({         @Index( members = {"children.name"}),         @Index( members = {"children.age"})     })   ... , which is much more efficient for the third query: @Index( members = { "children.name", "children.age" }) (with or

New issues with queries using build 2.7.6_08

.execution.ExecutionConfigImpl as config WHERE execution MEMBER OF ?1 AND execution.verdictID = verdict.uid ... .dmos.execution.ExecutionConfigImpl as config WHERE config.uid = '23A' AND execution MEMBER OF ?1

NullPointerException: Cannot invoke "com.objectdb.o.RFV.S()" because "" is null

;  @Indices({         @Index( members = {"children.name"}),         @Index( members = {"children.age"})   

javax.jdo.annotations.Persistent.dependent

JDO Annotation Attribute in javax.jdo.annotations.Persistent String dependent default "" Whether related object(s) of this member are dependent and so deleted when this object is deleted. Since: JDO 2.1

javax.jdo.annotations.Persistent.dependentElement

JDO Annotation Attribute in javax.jdo.annotations.Persistent String dependentElement default "" Whether the elements of this member are dependent. Since: JDO 2.1

javax.jdo.annotations.Persistent.dependentKey

JDO Annotation Attribute in javax.jdo.annotations.Persistent String dependentKey default "" Whether the keys of this member are dependent. Since: JDO 2.1

javax.jdo.annotations.Persistent.dependentValue

JDO Annotation Attribute in javax.jdo.annotations.Persistent String dependentValue default "" Whether the values of this member are dependent. Since: JDO 2.1

javax.jdo.annotations.Persistent.loadFetchGroup

JDO Annotation Attribute in javax.jdo.annotations.Persistent String loadFetchGroup default "" Name of the fetch-group to use when this member is loaded due to being referenced when not already loaded. Since: JDO 2.1

javax.jdo.annotations.Persistent.mappedBy

JDO Annotation Attribute in javax.jdo.annotations.Persistent String mappedBy default "" Name of the related member in the other class where this value is mapped (bidirectional relationship). Since: JDO 2.1

javax.jdo.annotations.Persistent.column

JDO Annotation Attribute in javax.jdo.annotations.Persistent String column default "" Column name where the values are stored for this member . Since: JDO 2.1

javax.jdo.annotations.Persistent.nullIndicatorColumn

JDO Annotation Attribute in javax.jdo.annotations.Persistent String nullIndicatorColumn default "" Null indicator column for this member . Used for nested embedded fields or properties to indicate whether the embedded instance should have a null value. Since: JDO 2.1

javax.jdo.annotations.Persistent.recursionDepth

JDO Annotation Attribute in javax.jdo.annotations.Persistent int recursionDepth default 1 Recursion depth for this member . Used only when the annotation is used within the definition of a FetchGroup. Since: JDO 2.1

javax.jdo.annotations.Persistent.extensions

JDO Annotation Attribute in javax.jdo.annotations.Persistent Extension [] extensions default {} Vendor extensions for this member . Since: JDO 2.1

javax.jdo.annotations.Transactional

JDO Annotation Transactional Target: ElementType.FIELD, ElementType.METHOD Implemented Interfaces: Annotation Annotation to indicate that a member (field or property) is transactional but not persistent. This corresponds to xml attribute persistence-modifier="transactional" of "field

javax.jdo.annotations.Value

) should be indexed. Since: JDO 2.1 String mappedBy default "" Name of a member in the key class

javax.jdo.annotations.Value.mappedBy

JDO Annotation Attribute in javax.jdo.annotations.Value String mappedBy default "" Name of a member in the key class where this value is stored. Since: JDO 2.1