So fix your file permissions. The following message cannot be more
clear
access denied ("java.io.FilePermission" "C:\" "read")
Why "C:\" is in the CLASSPATH only you would know
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" group.
To p
If you have a NoClassDefFoundError then you need to mention what is
the class ... likely the cause of that error.
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" group.
To post to this group, send email to google-appengine-java@googlegrou
http://code.google.com/p/googleappengine/issues/detail?id=6928
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" group.
To post to this group, send email to google-appengine-java@googlegroups.com.
To unsubscribe from this group, send email
> ConnectionPool : do any of C3P0, DBCP, or BoneCP work with CloudSQL ?
> If so then you can use DataNucleus support for those (look at the DN
> docs).
Apparently DBCP "works"
http://groups.google.com/group/google-cloud-sql-discuss/browse_thread/thread/a469cd08c2a2ac43
--
> I am using Gwt + gae + cloud sql + data nucleus, can anybody shed some
> light on how to do connection pool and how to monitor in-flight stats.
ConnectionPool : do any of C3P0, DBCP, or BoneCP work with CloudSQL ?
If so then you can use DataNucleus support for those (look at the D
Actually presenting a complete "persistence.xml" and an accurate
description of the problem would be a prerequisite to people
understanding what you're going on about. Just an idea ;-)
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" group
Unowned relationships are supported on GAE, using v2 of their
DataNucleus plugin, as are M-N relations
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" group.
To post to this group, send email to google-appengine-java@googlegrou
> A little more info on my example too.
I'll refer you to my previous comment then.
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" group.
To post to this group, send email to google-appengine-java@googlegroups.com.
To unsubscribe from t
ure that it ought to be perfectly simple to generate
a testcase something akin to the format used by DataNucleus
http://www.datanucleus.org/project/problem_jdo_testcase.html
if the issue is as clear as you say in terms of reproducing it. And
then you can raise an issue in Googles issue track
Probably a bug, but you could just use the more normal
Query q = pm.newQuery(MyClass.class);
List results = (List)q.execute();
which is widely tested in Googles tests.
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" group.
To post to this
> Also, I did not have a persistence.xml file in eclipse so I copied the one
> provided on the wiki's link and placed
> it alongside jdoconfig.xml in hope that this would be enough.
And why should you have one? You use one or the other. As per the JDO
spec.
> Why is
> org.datanucleus.store.appen
Who can say; you need to define what you're doing. So look at
http://code.google.com/p/datanucleus-appengine/source/browse/trunk/tests/com/google/appengine/datanucleus/jpa/JPAManyToManyTest.java
and write a test, using that same sample, with the operations you're
performing.
--
Yo
To make a relation unowned (in v2) you mark (both sides if
bidirectional) as @Unowned
Unowned M-N work fine with SVN trunk code, though there may have been
some things incomplete in RC versions
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Ja
> Just a last thought: in this way I have to retrieve all the children
> each time I want to order the collection .. Am I right?
You retrieve the owner object, and it has a List. You play around with
the List to your hearts content, and the updates are saved.
> I hope it is integrated with the se
How to order it ? you set the items in the list in the order you want
them, of course.
Manual hackery of properties in the datastore means that you take
responsibility for it thereafter - v2 of the plugin (the latest
storage version) actually stores the positioning and membership in a
property in t
There aren't any books on JDO2+ AFAIK. Best place to learn about it
are
Apache JDO, who manage the API : http://db.apache.org/jdo/
DataNucleus docs (all pages under "JDO API" menu) :
http://www.datanucleus.org/products/accessplatform_3_0/jdo/api.html
JDO spec (linked from the a
@Rick,
JDO doesn't encourage you to do anything, nor impose it. Perhaps its
just that some will, upon using it, think in a particular way because
they used a similar API before, and they're used to their "good old"
RDBMS handling things for them so assume the same is true ... and it
isn't as you s
As for the problem of the original poster, evictAll is for the
*Level1* cache (which will not be of any use since you aren't using
transactions there). Calling addLabels is queued (doesn't go straight
to the DB in the version you use there), and you don't then start a
transaction. Simple thing to d
> JDO was designed for relational data models, GAE was designed for the
> opposite.
Please check your facts, perhaps by consulting people who actually
designed the JDO standard, or by actually reading the JDO spec. It was
designed to be datastore-agnostic. JPA on the other hand was not, with
RDBMS
> Well, it sounds so. But does (or can/will) Datanucleus support at least
> some of the features Jeff has mentioned?
Yes, several actually. And nothing is "dog slow", ... though why dogs
get such a bad reputation I've no idea; take a greyhound for
example ... :-)
The questi
> *Does anybody know whether it's as simple&transparent as with Objectify to
> use GAE's caching in JPA2&Datanucleus on GAE?*
Assuming you're using v2 of the datanucleus-appengine plugin, just
define the persistence property "datanucleus.cache.level2.type
> 2), I don't pass objects between PMs.
Well I can only comment on your example, which closes the PM after
persist (so the object goes to hollow then to transient), and *then*
you check on field values. Things will be nulled unless retainValues
is set. See
http://www.datanucleus.org/products/acces
e their
field values present (since the object is now in HOLLOW state).
A review of the JDO spec and in particular object lifecycle would make
sense.
Using v2 of the datanucleus-appengine plugin (the only version I have
any interest in), such an operation works fine.
--
You received this message b
Earlier blog post
http://datanucleus.blogspot.com/2011/08/gaej-and-datanucleus-v3.html
and more recent one
http://datanucleus.blogspot.com/2011/11/gaej-and-datanucleus-v3-part-2.html
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java&q
> how does the unowned relationships works? Does it enable "lazy loading" the
> related part as a separated datastore get?
@PersistenceCapable
public class A
{
@Unowned
B b;
}
@PersistenceCapable
public class B {...}
Persist of an A with related B will persist the A and B (though the
Ke
> I don't know how you would force a write using JDO.
JDOHelper.makeDirty(obj, "fieldName);
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" group.
To post to this group, send email to google-appengine-java@googlegroups.com.
To unsubscrib
Since that version of GAE uses an ancient version of DataNucleus, you
could simply put your update code within a transaction.
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" group.
To post to this group, send email to google
and pm variable is defined where? one per thread?
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" group.
To post to this group, send email to google-appengine-java@googlegroups.com.
To unsubscribe from this group, send email to
google-ap
Use DataNucleus Excel plugin perhaps, and Apache POI ... assuming GAE
restrictions on classes don't prevent it.
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" group.
To post to this group, send email to google
> Not sure what all the low-level difference between the two is
> either
One of them returns objects in a "detached" state (i.e representations
of persisted objects, with an "identity", but disconnected from the
datastore, and if persisted would update the existing object in the
datastore)
The ot
> however i have the following issues.
>
> 1.I am using the query Select c from ChatUser c where c.key =:keyList
> elsewhere and it is working fine. How can it be working?
Because Google didn't respect valid JDOQL when they implemented their
plugin and allowed nonsense like that query (the syntax
Invalid JPQL (a Key cannot equal a List). This makes more sense
Select c from ChatUser c where c.parentKey IN :parentKey
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" group.
To post to this group, send email to google-appengine-java@goo
Perhaps you ought to define your persistence code and more of your
model classes (and stack trace). When I run something like that
**using SVN code of the GAE plugin** all works fine.
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" group.
oogle.com/p/datanucleus-appengine/issues/list
If it exists there, then refer to it so the user knows which one to
star
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" group.
To post to this group, send email to google-appengine-java
> A question about the "ancient version of DataNucleus" you mention:
> Is there a more up-to-date approach I should be using within GEA? Could you
> point me toward the resource for that if any?
Nothing you can do (apart from getting the code for the GAE/J
DataNucleus plu
d the object is
managed, and so any update will go to the DB without any
makePersistent call being needed (obviously in the ancient version of
DataNucleus you have there it will wait til the next txn before it
does (or just put the pm.getObjectById+update in a txn).
--
You received this message be
Something you have there is using JPA2, yet the GAE/J code is only for
JPA1.
Identify what is causing that error, and fix it to use JPA1.
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" group.
To post to this group, send email to google-a
> This shit happens to me all the time.
> You JUST need to edit your persisting class, add a space somewhere,
> and have datanucleus rebuild your class persistence stuff.
Which is nothing to do with his problem.
The problem in your case is Google's Eclipse plugin seems to have
prob
And that is the developer who has left it open to that. Any sane
developer would have put "parameters" in the query
> String q = "select from Employee where managerID == :user && lastName ==
> :name";
and there any vulnerability disappears. :-P
Besides which the query written like that would
> That is incorrect. You can specify a filter using the == with a single value
> and a list or set such as
You mean AppEngine allows you to; this doesn't mean it is correct to
do that. JDOQL prohibits it (see the spec). JDOQL follows Java, and
the syntax Matthew gave is the valid one, not this. If
> The query language is more or less same for datastore as relational
> db, so any thing could happen to relation db querying could
> happen to datastore querying.
Not true. JDOQL is parsed by a parser and converted into a datastore
query; SQL is not. JDOQL queries do not go there direct. The pars
> query = "select from " + PocVacationSchedule.class.getName() + " where
> pocId.contains(" + pocIdList + ")";
>
> where podIdList is a java.util.List of type Long
Now please tell me, in Java, would you do
"Long.contains(List)" ?
No. Thought not. On the other hand you would do
"List.contains(Long
Your JDOQL query ? Where in the spec for JDOQL does it say that there
is an operator "IN" ? JDOQL is Java syntax, so collection.contains()
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" group.
To post to this group, send email to google-
SQL injection ? into a database that doesn't support SQL? Please
present a clear example of how such a thing can happen and what effect
it can have. The application designer is the person who allows such a
thing, not the underlying API
--
You received this message because you are subscribed to th
Perhaps because JPA is an API and query language designed solely
around and for RDBMS. And this is not RDBMS. JDO and JDOQL, on the
other hand, were designed to be datastore agnostic, and object-centric
--
You received this message because you are subscribed to the Google Groups
"Google App Engi
> So basically now i want to query all IntrestedParties where parties list
> contain User(1) or User(5) etc.
How would you write that as a line of Java ?
parties.contains(:user1) || parties.contains(:user2)
--
You received this message because you are subscribed to the Google Groups
"Google App
> The behavious of DataNucleus depends on the strategy I choose to generate the
> @Id field.
Obviously, as per DN docs (and why I asked you to show your class) :-
If using pessimistic txns, then all persist/update/delete operations
happen immediately. Consequently it doesn't matter
> The behavious of DataNucleus depends on the strategy I choose to generate the
> @Id field.
As per the docs for DataNucleus then, which is why I asked you to show
your class (and you didn't).
If using pessimistic txns then any persist/update/delete will go to
the datastore when inv
I've already asked you twice to post your class. You haven't. That
provides no context for any comment, and I've already told you why
datastore operations are delayed until commit/flush. Why do you think
there's a flush() method if you think things ought to go straight to
the datastore ?
JPA2 spe
http://www.datanucleus.org/development/test/jpa_tck.html
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" group.
To post to this group, send email to google-appengine-j...@googlegroups.com.
To unsubscribe from this group, send email to
go
optimistic versioning problems. An object being
attributed in the datastore (which is what IDENTITY GeneratedValue
type is) cannot have an identity *value* until it is flushed since it
isn't *persistent* until then. And while you're at it you can run
DataNucleus against H2.
You should no
g managed
> means that the entity has a persistent identity, something not true here.
There is nothing in the JPA spec to require the identity to be set
before flush(). If there was do you really think that DataNucleus
would pass the JPA1 TCK ? (which it does).
> In my opinion this is a
> I'm using version 1.3.3.1 of the SDK. I've seen the problem mentioned
> on various blogs and even the App Engine group I believe but the
> answer is always JDO related (dealing with fetch groups). Am I doing
> something wrong or has anyone else had this problem and solved it for
> JPA?
JPA has a
> i wanna know if this is a supported feature not a hack
JDO allows "value-strategy" on any field. JPA only allows it on the PK
field(s) only.
I'm assuming GAE/J is supporting this, but that's for you to find out.
--
You received this message because you are subscribed to the Google Groups
"Goo
> Built-in object id classes not working in Google data store,
Well they are working fine actually ... but as I already said you're
using more than 1 field and THERE IS NO BUILTIN object id for
composite id.
> we worked as example given in the fallowing url
> http://www.datanucleus.org/products/a
ss; so provide one. JDO
only provides built-in object id classes when you have a single field
as PK. The DataNucleus docs define how to define your own.
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" group.
To post to this gro
You mean a transaction failed to commit and you don't tell us the real
reason, so people have to guess ? Any such exception has a nested
cause.
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" group.
To post to this group, send email to go
The syntax is perfectly fine. The fact is though, you have to have a
particular java type to be "supported" for persistence to be able to
query against it. I doubt that GeoPt is, though DataNucleus allows
extensions to permit such a thing to be enabled; just that Google
would have to en
SELECT FROM mydomain.MyClass where myPkField = :val
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" group.
To post to this group, send email to google-appengine-j...@googlegroups.com.
To unsubscribe from this group, send email to
google-
And DataNucleus docs for v2.0, v2.1 don't mention GAE/J since GAE/J
doesn't work with them, and we've been given no timescales when it
will.
The DN v1.1 docs mention GAE/J, but we have absolutely no intention of
mentioning caveats to specifications necessary to run GAE/J - since
y Role(1) has
> already been persisted without a parent. A parent cannot be established or
> changed once an object has been persisted.*
>
> *Datanucleus* Got it?
There is nothing to "get" from my perspective.
JDO and JPA define two ways of storing a referenced object :-
1.
> *Google says "unowned relationship is not supported"*
> What does it mean? *How datastore identify that *it is unowned
> relationship**?
No idea. It's a Google special. It's not part of any spec so it's for
them to answer.
> In above example, If I implement it as normal relationship, as shown
You will only find "unowned relationships" terminology in Google docs.
This "unowned relationships" in the GAE/J docs is where you have a
field that is a "Key" or a Collection/Map/array of keys. So no *real*
relation, just some implicit relation by that "key". You have to
manage these keys yourself
Does it "implements Serializable" ? No.
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" group.
To post to this group, send email to google-appengine-j...@googlegroups.com.
To unsubscribe from this group, send email to
google-appengine-ja
> So a Person can have a favored Food. But a Food is not linked to only
> one Person, but can be the favored Food of more than one Person.
> Ok, I understand that we don’t have a Food-Object in the class Person,
> but instead we have the Key to the food.
> Ok, now I want to get the favored Food Obj
> what is the difference between owned one to many relationship and
> owned one to many bidirectional relationship
If it has a "mappedBy" then it relates one side of the relation to the
other side ... hence bidirectional. There are only two types of 1-N
relation ... unidirectional (no mappedBy) an
> Your Problem is due to a bug in DataNucleus described at
No. That is a bug in Google's plugin, since that is their issue
tracker you refer to.
DataNucleus current version is at version 2.1, whereas what you use
there is v 1.1.x
--
You received this message because you are subscribe
> How to update some existing data in datastore post an example or any
> link.
Retrieve an object and update it perhaps ?
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" group.
To post to this group, send email to google-appengine-j...@g
> So i've got two serializable classes and one contains a list to the
> other and it just does not want to pass this to my service without
> throwing this error message.
So raise it on the GWT group. It's their software causing the problem.
--
You received this message because you are subscribed
Yes, but every exception has a stack trace. Every one. Catch the
exception and call e.printStackTrace(). Knowing which of your method
calls results in the exception is the only answer.
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" group
> I have a method which will create a comment on some content. The Web
> page updates correctly but the call to save ServerContent never works.
> I get a silent failure in by AsyncCallback and it throws a
> com.google.gwt.user.client.rpc.SerializationException with the details
> null and stacktrace
> like i said before
> " DataNucleus has no way of "seeing"
> the changes you make to the internal values of a serialized field, and as a
> result it doesn't know when it needs to flush changes to these fields to the
> datastore. However, DataNucleus *can
I'm sure referring to the log would tell you way more, like when an
object becomes dirty, and when it is persisted and changes lifecycle
state.
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" group.
To post to this group, send email to go
> > Is exsists any other way to get objects by one query from program, if
> > I don't sure in exsists every of it?
Errm, a JDOQL query perhaps
SELECT FROM mydomain.MyClass WHERE :idCollection.contains(id)
and pass in a collection containing the ids of the objects you need.
--
You received this
> Thanks a lot for the thoughts Hani, but I do only want the children,
So do a JDOQL query for the elements
pm.newQuery("SELECT FROM MyElement WHERE myParent == :parent");
and pass in the parent object, and add on any other filter
requirements.
--
You received this message because you are subscr
> Sorry if this have been asked before. I just started using
> datanucleus JDO. Compare to sybase/oracle/mysql, I can not find much
> tools available for simple task such as make a backup, import data, a
> gui to browse data.
Perhaps you ought to read up on what JDO is first. It
> I turned the relationship around and it managed to work, but I still
> liked your idea of embedding the user class better since there will be
> no user without a person object.
You could use @Embedded with JDO (assuming Google have implemented
it), and then if you use it against an RDBMS in the
> I want to create JDO query with 4 arguments, but in Eclipse I got
> error, that only 3 arguments are allowed.
> List results = (List) q.execute(companyKey, true, true, false);
Why not look at the JDO API ? It's a standard after all.
http://db.apache.org/jdo/api23/apidocs/index.html
executeWithA
Specify ordering in one call
setOrdering("nom ASC, prenom ASC");
This doesn't fix the issue with accented letters though
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" group.
To post to this group, send email to google-appengine-j...@go
package-{datastore}.xml
is there for exactly that purpose.
e.g package-appengine.xml, package-hsqldb.xml, package-oracle.xml
See the DataNucleus docs
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" group.
To post to this g
I see no lifecycle status log entries; perhaps this is turned off. Or
use JDOHelper.getObjectState(object) to see what state an object is in
when retrieved from the find(), and then after the setValue(). I also
see no transaction log entries.
--
You received this message because you are subscribe
> I think you've misunderstood where problem is.
I simply point out where the persistence code is plain wrong; whether
that has an impact on what happens after is unknown. Debugging what is
happening in that particular operation you quote there ought to make
reference to the log at DEBUG level sin
I refer to your method "generateItems(Key containerKey)" where you do
Item item = new Item();
item.setContainer(container);
item.setValue(Integer.toString(i));
em.persist(item);
Where did you put the item in the List exactly? You set the owner of
the item as this container, great, but it's not in
> I'm not serializing List's data in a single column so I don't have to
> force entities to update, if I'm not mistaken.
You are setting only one side of a relation from the code you present.
If the relation is bidirectional then you ought to set BOTH sides. JPA
does not come with "managed relatio
JDO to cache that collection. It
> might be possible, but I couldn't figure it out.
DataNucleus 2.x has L2 caching enabled by default, and caches
relations (1-1, 1-N, M-N). Sadly GAE/J still doesn't support that
version and no sign of when it will either (in fact DN 2.1 is in
progress so
getObjectsById(...)
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" group.
To post to this group, send email to google-appengine-j...@googlegroups.com.
To unsubscribe from this group, send email to
google-appengine-java+unsubscr...@googl
> I'd like to avoid having to lookup the object using the Key and then
> updating it, and was wondering if I could get away with using the
> makePersistentAll method as a shortcut. The docs seem to imply I
> could do this if the object was detached, but not sure how it would
> behave if it was a r
> No available StoreManager found for the datastore URL key "jdbc
Since when has GAE/J been an RDBMS datastore ? Their docs state very
clearly to use "appengine" as the DatastoreURL
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" group.
> OK, but it does not work with GAE. My persistence.xml contains name="javax.jdo.PersistenceManagerFactoryClass"
> value="org.datanucleus.jdo.JDOPersistenceManagerFactory"/>, but
In GAE/J the class ought to be
org.datanucleus.store.appengine.jdo.DatastoreJDOPersistenceManagerFactory
> following
You mean because the JDO spec defines this behaviour ? Familiarisation
with the persistence specification makes a lot of sense
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" group.
To post to this group, send email to google-appengine-j.
> Where can I find way to specify the class list? I have found
> http://www.datanucleus.org/products/accessplatform_1_0/jpa/persistenc...
> , but it is for persistence.xml and JPA.
And this
http://www.datanucleus.org/products/accessplatform_1_1/jdo/persistence_unit.html
which is for JDO, and persi
> The objects have been detached.
Ok. So the objects *have* been read from the datastore, since to
detach them you obviously have to retrieve them first ... then detach
them. And the exception is presumably coming from GWT, but then I
don't see your stack trace so have no way more than guessing.
"List" is not enhanced. ever. Neither is String or any other type.
"Enhancement" simply adds on new methods to manage detection of
changes to fields. That's all. Any persistence mechanism that wants
efficient management of updates needs enhancement. Why not determine
where the problem is with your
Why read JPOX docs when JPOX was replaced 2 years ago? by the same
DataNucleus software being used by GAE/J. It's website would make more
sense (and is linked to in various places from the GAE/J docs).
> I also don't understand it exactly. I thought that JDO uses
> jdocon
You mean, like what a Level2 cache is for, in JDO and JPA ? hence
cutting out the need to cache things manually ...
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" group.
To post to this group, send email to google-appengine-j...@googlegr
DataNucleus enhances the classes when you tell it to; compile time,
post-compile, or runtime. You can use unenhanced classes on client,
and enhanced on server without issues
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" grou
There are past threads on here discussing the issue. The log tells you
timings of what is happening. persistence-unit can be defined with the
persistable classes only so it doesn't have to scan the classpath.
Only when you present timings can anyone comment
--
You received this message because yo
> there could be a fluke with how DataNucleus+GAE interpret a particular
> feature/annotation
The log would tell you if that was the case. More likely the GAE/J
Eclipse plugin of hasn't detected a change in the source file.
Obviously there is also the DataNucleus Eclipse pl
I said have a dummy class with an ArrayList, not a dummy class with a
multiple-dimension array. I also said make the dummy class
persistable ... @PersistenceCapable. Nothing worthy of an example
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for J
So you didn't declare the dummy class as persistable like I mentioned
that you ought to do ...
--
You received this message because you are subscribed to the Google Groups
"Google App Engine for Java" group.
To post to this group, send email to google-appengine-j...@googlegroups.com.
To unsubscr
1 - 100 of 309 matches
Mail list logo
