Customer Reviews

Grails Persistence with GORM and GSQL

5 star:		(4)
4 star:		(5)
3 star:		(1)
2 star:		(2)
1 star:		(2)

 

 

The other reviewers are complaining there's not much here. I admit I picked it up in eBook format hoping to get a detailed, deep dive into the very bowels of Grails persistence. This isn't that book.

What I did find is that it's ideal for someone new to Grails, to understand all of the options available to you for persistence-level work. Everything from the basics of domain classes through Hibernate-land all the way down to raw SQL. It's a short survey work - which I should have expected given that it's by FirstPress. Give it to the new Grails developers on your project - this is stuff they NEED to know and they can read it in a couple of hours.

I got a second copy for our DBA. This is her first foray above the database level into helping with the application programming level. It's helping her understand where we developers are coming from, and to give us better advice.

Recommended as a starter work to understand your options. But to go deeper into Grails or Hibernate, you'll want an additional book. I recommend Grails in Action and Java Persistence with Hibernate.

This is a good, quick guide to persistence in Grails. It follows a good pattern: Here's some short code, here's an explanation, and here's an integration test to cover the details. At times, this style is too quick, sketching over details and leaving me without a complete understanding.

The book doesn't talk about setting up your Grails environment. It's clearly aimed at people who already know how to use Grails but want a more thorough understanding of how to use their domain objects. All of this information is online, of course, but as the author points out a couple of times, the official documentation has always contained some inaccuracies. So this book is a good supplement. Is it a good read? Not really. It doesn't use an example project. It doesn't tell you how to built a better database. It assumes you know what you want to do and tells you how to do it. I mean that in the best possible way: Despite the popularity of Grails, info on best practices remains hard to find, and the source code in this book is very sleek, well-tested and Grails-y.

Whereas every Grails developer absolutely must have The Definitive Guide to Grails, Second Edition, which covers GORM pretty well, this book is good for reference. Not, however, in its slim, oversized-text print edition, which, as a FirstPress book, doesn't even have an index. I'd recommend it as an eBook only.

At first I was surprised that it was a total of 156 pages (I was pleased that I didn't have to work my way through yet another 700 page book).

As the title indicates this is focused on one of the greatest assets of Grails, GORM. When working with GORM, you really need examples and options to help you with common data query and dataset organization tasks, this book provides that.

In a nutshell, if you are working on a Grails project, this book will provide you with a concise reference with great code examples of valuable GORM features that you will refer back to.

This book was intended for the beginner-to-immediate developer, and so those who are already pros may find it a bit simplistic (although I'm not sure). It was also intended to be a lot more accessible than the more thorough and in-depth "Definitive Guide to Grails" or "Grails in Action": it was supposed to be a bit of a handbook instead of a deep dive.

The emphasis of this book was on demonstrating clear and provably-correct code around GORM: I wanted to write a test-driven book so that if you encountered problems in your code, you could figure out how to test them. I also wanted to show that I was not only asserting how things *should* work, but really demonstrating how things *do* work.

Once these basics were covered, I proceeded to go into some tips and tricks I knew. Although much of the first third of the book is either demonstrations of or corrections to information available through Grails online resources, the last two thirds of the book comes directly from my conversations and problem solving as part of the Grails-User mailing list and as an independent Grails consultant. Although some of the tips and tricks might be obvious to an established Grails professional who has been keeping up with Grails-User for the last couple of years, many of the stunts I outline were surprises or tricky to get right for me when I first encountered them. Because of that, I wanted to share these stunts more widely.

If you'd like to see an expanded and updated version with more details, I'd encourage you to contact APress and let them know. The FirstPress nature of the book was extremely constraining -- I pushed right up against the 150 page limit of the FirstPress format, and while I tried to cram as much meet as I could into 150 pages, there's naturally stuff that was going to be left out. I'd be very interested in doing an expanded and updated version of the book for Grails 1.2 (whenever that finally comes out).

Probably a bit dated nowadays, but when I was first dealing with Grails (1.1, 1.2) and GORM this book's quick test-driven examples were ideal for me. I liked not having to deal with some big overarching tutorial project (I had my own project to worry about!) I stopped using Grails for a while, and I'm just coming back as 1.4 comes along - and I wish there was an update to the book, I'd buy it again...

If you can find this in a library or borrow it, it's certainly worth reading through. It might take all of an hour and a half. With the large font size, there's really not much content. It feels like 40 pages of content in a more standard font size.

On the positive side, the ideas were organized and the writing is clear.

On the negative side, there is no depth to any of the topics. Aside from collecting all persistence-related topics together, there's nothing this book provides that the latest Grails User Guide doesn't provide better.

I don't know what audience this book is for. Perhaps for someone who wants a quick survey over GORM, but doesn't actually need to develop. If you're a developer, either Beginning Groovy and Grails: From Novice to Professional (Beginning from Novice to Professional) or The Definitive Guide to Grails are far better books for your library and both touch on everything contained in this one.

Grails Persistence with GORM and GSQL is a good handbook book for anyone who was to learn GORM. The table of contents is well laid out to allow the reader to quickly get to their desired subject. The author does a good job of illustrating the various parts of GORM and its subtleties (sorting, filtering, showing only a certain number of rows per page, etc. The author also does a good job of illustrating test driven development since each of his concepts is illustrated by a Unit test to demonstrate each of his concepts.

The only parts of the book that I would improve on would be to give more examples in his GSQL of some of the queries and illustrate some of the other Groovy Query and update methods. I would also have liked to see a few more examples of the identity objects and how they can be used in different situations.

Overall, this is a good quick guide for anyone looking to work with GORM.

LARGE TYPE which with my eye sight is good but the book is thin to start with. It's like writing your 4rd grade homework and the teacher asked for 5 pages so you write big.

Not sure if Apress or the Author was just lazy or if they really consider this a worthy book. If you look on the Roadmap on the back of the definitive guide they show this as the next book on the roadmap.

REALLY DISAPPOINTED. The book is basicly the test cases for validating GORM, rudimentary. It's as if, and I am almost certain this is the fact, APRESS solicited books and Robert Fischer went to the john and pinched off a couple of chapters.

I really needed a deeper project focused book with more involved queries. Granted, I am looking for a solution to a problem and the answer either does not exist or I have yet to soak up the light.

The book title should really say 'Basic Validation of' Grails Persistence with GORM and GSQL.


Here's what I was looking for and you won't find it in this book, I was able to hack this out given MarkMail messages. Many of which Fischer contributed to...I appreciate his contribution to the Grails project I just wish Apress & Fischer would have taken more time, payed him a stipend to create a more advanced book, especially given this is one of the only books specifically for GORM, GSQL.

I hope someone finds this constructive.

Really the issue is learning the ins, outs of the Hibernate Builder, which I am still trying to understand.

Could not get the formatting to stick. So,indents are removed.
[code]
calling routine
{
....Other processing to setup the query.....
.... Html page multi select dropdown request user input for columns to display i.e. "projections"
.... Html page for each column input box this becomes the "columnsmap"
.... user can enter multi strings in input box to filter a search in the OR part of query
.... value= split of input box\
.... This is Powerful dynamic stuff.

params.max = Math.min(params.max ? params.max.toInteger() : 10, 100)

params.useMax=false
def klmQueryTotal = Klm.createCriteria().count(defaultKlmQuery)

params.useMax=true
results = Klm.createCriteria().list(defaultKlmQuery)

println "count=$klmQueryTotal"
println "results.size()=$results.size()"
// results.each
// { println "results=$it" }

[ paramsList:params, columnList:columnsmap.keySet(), resultList:results, klmQueryTotal:klmQueryTotal ]
}
// columnsmap is a map of the columns to include and assoc. string to use as a where condition.

def defaultKlmQuery =
{
println "Hello projections - $params"

projections
{
println "projections{"
columnsmap.each
{key,value->
println " property($key)"
property(key)
}
println"}"
}
and
{
println "AND1"
// where customerName like 'gil%' or customerName like 'for%'
// and siteName like 'atl%' or sitName like 'aust%'

columnsmap.each
{key,value ->
println "$key,$value size="+ value.size()
println "join ="+value.join().size()

if (value.join().size() != 0)
{
switch(key)
{
// OR the _id Elements of KLM
case 'customer':
case 'site':
case 'serviceInfo':
case 'mtu':
case 'config':
case 'software':
case 'salesOrder':
println "OR $key like $value"
or{
value.each
{searchkey ->
println "Or $key{ ilike('${usecolumn[key]}','$searchkey') }"
"$key"{ ilike(usecolumn[key], "%${searchkey.trim()}%") }
}
}
break;

// AND the KLM elements
case 'sn':
case 'soNumber':
//for each in list if value is a list
value.each
{searchkey ->
println "And $key{ ilike('${usecolumn[key]}','$searchkey') }"
ilike(key,"%$searchkey%")
}
break;

}
}
}
}
if ( params.useMax == true)
{
maxResults(params.max)
if (params?.offset)
firstResult(params.offset.toInteger())
}

// sqlRestriction "distinct sn"
// sqlRestriction "sn in select * from klm where sn='2'"
// addToCriteria('select distinct sn from klm')
// addToCriteria(Restrictions.sqlRestriction('sn in (select distinct sn from klm where user_tbx is null)'))

}
[code]

This is an excellent and worthwhile purchase for the beginning and intermediate Grails developer. I especially liked the 'test-driven' style used to prove his assertions on how GORM actually works.
If I do have a criticism, it's that its too short. I might suggest extended examples, especially with Criteria Builder and associations, and a good set of solutions to 'gotcha's using GORM. The 'gotcha's would be easy to find on the grails user list.
All in all, a must have for any grails/gorm developer. I'm hoping there's a 2nd edition on the way soon.
Thanks Robert for the excellent resource.
Burt Prior

This is a great introduction and overview of GORM for beginner and intermediate Grails users. It is very thorough, and covers all code examples with working test cases. There are some excellent real work cases that I've run into as a Grails develop as well, including linking domain classes (has-many-through relationships). This is a much better tutorial for GORM that you will find anywhere on the web.