class Application {
BigDecimal gpa
Date submitDate
String appliedFlag
String acceptedFlag
String deniedFlag
String managerNetid
Date timeStamp
AcademicYear academicYear
Quarter quarter
Student student
Set<ApplicationFile> applicationFiles = []
Set<ApplicationQa> applicationQas = []
Set<ApplicationAccepted> applicationAccepteds = []
Set<ApplicationDenied> applicationDenieds = []
 
static hasMany = [applicationAccepteds: ApplicationAccepted,
                  applicationDenieds: ApplicationDenied,
                  applicationFiles: ApplicationFile,
                  applicationQas: ApplicationQa]
 
static belongsTo = [AcademicYear, Quarter, Student]
 
static mapping = {
version false
quarter column: "quarter_code"
student column: "sid"
applicationAccepteds cascade: "save-update, delete-orphan"
applicationDenieds cascade: "save-update, delete-orphan"
applicationQas cascade: "save-update"
}
 
static constraints = {
submitDate nullable: true
appliedFlag maxSize: 1
acceptedFlag maxSize: 1
deniedFlag maxSize: 1
managerNetid nullable: true, maxSize: 36
}
}

There used to be a plugin for Grails that had this functionality and uses the hibernate-tools library but it stopped being maintained a while ago and the newer Grail releases are not compatible. I figured since MyEclipse uses the same hibernate-tools to generate Java code that maybe it would be possible to expand on that to generate Grails domain classes?

http://grails-plugins.github.io/grails-db-reverse-engineer/grails3v4/index.html

Depends on Hibernate Tools, Maven, Eclipse

https://hibernate.org/tools/

Golang GORM

GORM - create tables from GOR

http://jinzhu.me/gorm/

• Full-Featured ORM (almost)
• Associations (Has One, Has Many, Belongs To, Many To Many, Polymorphism)
• Callbacks (Before/After Create/Save/Update/Delete/Find)
• Preloading (eager loading)
• Transactions
• Composite Primary Key
• SQL Builder
• Auto Migrations
• Logger
• Extendable, write Plugins based on GORM callbacks
• Every feature comes with tests

install

go get -u github.com/jinzhu/gorm

simple crud example

package main

import (
    "github.com/jinzhu/gorm"
    _ "github.com/jinzhu/gorm/dialects/sqlite"
)

type Product struct {
  gorm.Model
  Code string
  Price uint
}

func main() {
  db, err := gorm.Open("sqlite3", "test.db")
  if err != nil {
    panic("failed to connect database")
  }
  defer db.Close()

  // Migrate the schema
  db.AutoMigrate(&Product{})

  // Create
  db.Create(&Product{Code: "L1212", Price: 1000})

  // Read
  var product Product
  db.First(&product, 1) // find product with id 1
  db.First(&product, "code = ?", "L1212") // find product with code l1212

  // Update - update product's price to 2000
  db.Model(&product).Update("Price", 2000)

  // Delete - delete product
  db.Delete(&product)
}

Generate Golang structs from SQL databases

https://github.com/smallnest/gen

could create a converter to generate GORM domain classes from Golang structs

or

directly create tool to build GORM domain classes from db tables using JDBC metadata and groovy

benefits of direct tool:

• no external dependencies
• could extend to NoSQL
• can pickup reference relations as "has" or "owns"
• can pickup primary key

Grails with Groovy 3x

4.1 M builds use Groovy 3

https://github.com/grails/grails-core/releases/tag/v4.1.0.M1

Potential Value Opportunities

Potential Challenges

Grails Java JDK compatibility

At some later point, ( 2020 or ? ), Grails will catch up with supported Java JDKs but not now.

The low-end default that will work is always JDK 8.

Groovy 2x still works with JDK 8 ( used by Grails 4x ) but not JDK 11 without a lot of custom work.

Grails 4 upgrade issues related to Java etc

https://github.com/grails/grails-core/wiki/Grails-4-Upgrade

Bug> Grails console can't open groovy file from menu or cli

bug> can't open a file from grails console using the file menu

workaround> use CTL + O

1. open groovyconsole normally
2. use CTL + O to open file selector window
3. select a groovy file
4. press Enter
5. << file opens normally in groovy console

option 1> specify the file name on the cli cmd to open grails console
specify the file to open on the grails console command using relative url
grails console -f ./zfiles/gtest-2a1.groovy
<< no file shown

option 2> manually copy file contents to console window
open grails console
open the file from the File menu ( nothing shows )
open the same groovy file in another text editor
copy and paste the entire contents to the console window
add a comment line
File > save
check the saved file in the text editor to see the comment line exists

Grails 4.1 M++  – Groovy 3 and JDK11

Candidate Solutions

SWT Grails Books and Authors Lab - 2009 - V2X

<< see the pdf for the images >>

Grails lab concepts

The Grails lab uses the c:\ebtnoweos folder to build and run your Grails Web database application.
You will use both the Explorer browser and a DOS cmd shell to generate and run your Grails Web
application.

Before you begin you'll need to start the WebSphere Community Edition server (WAS) that includes
the Derby database you'll use to store you data. You start WAS by clicking wcestart from Explorer.

At the end of the lab click wcestop to end the WAS server.

grails lab flow

• Understand grails datasource configuration
• Start wasce derby server
• Create-app qwex1
• create-domain-class author
• console edit for author
• generate-all for author
• create-domain-class book
• console edit for book
• generate-all for book
• run-app
• open a browser by clicking: http://localhost:9080/qwex1
• create authors
• create books

grails datasource configuration options

The datasource config file defines how grails uses a target database for a specific environment
( development, test or prod )

Sample datasource.groovy config file for the lab

dataSource {
pooled = true
driverClassName = "org.hsqldb.jdbcDriver"
username = "sa"
password = ""
}
hibernate {
cache.use_second_level_cache=true
cache.use_query_cache=true
cache.provider_class='com.opensymphony.oscache.hibernate.OSCacheProvider'
}
// environment specific settings
environments {
development {
dataSource {
dbCreate = "update" // one of 'create', 'create-drop','update'
url = "jdbc:hsqldb:mem:devDB"
}
}
test {
dataSource {
dbCreate = "update" // one of 'create', 'create-drop','update'
url = "jdbc:derby://localhost:1527/sample"
driverClassName = "org.apache.derby.jdbc.ClientDriver"
username = "APP"
password = "APP"
}
}
testh {
dataSource {
dbCreate = "update"
url = "jdbc:hsqldb:mem:testDb"
}
}
testm {
dataSource {
dbCreate = "update"
url = "jdbc:mysql://localhost:3306/sample"
driverClassName = "com.mysql.jdbc.Driver"
username = "root"
password = ""
}
}
production {
dataSource {
03/14/09 Jim Mason, copyright 2009 3 of 18
ebt-now Enterprise Open-Source Labs
dbCreate = "update"
url = "jdbc:hsqldb:file:prodDb;shutdown=true"
}
}
}

Edit the grails configuration for your data source

When you create your grails application, it generates a default datasource.groovy

config file that does
not include the references for derby and mysql as shown above.

You'll copy the datasource.groovy file

from the savedata folder ( C:\ebtnoweos\savedata\grails)

overlaying the generated version of this file in the

C:\ebtnoweos\grails\qwex1\grails-app\conf folder of
your application.

dbCreate controls how the database tables are maintained from grails
The dbCreate property of the DataSource definition is important as it dictates what Grails should do at runtime with regards to automatically generating the database tables from GORM classes.

The options are:
 create-drop - Drop and re-create the database when Grails is run
 create - Create the database if it doesn't exist, but don't modify it if it does. Deletes existing data.
 update - Create the database if it doesn't exist, and modify it if it does exist

Both create-drop and create will destroy all existing data hence use with caution!

To prevent ANY database changes, comment out dbCreate in the config

In development mode dbCreate is by default set to "create-drop":

dataSource {
dbCreate = "create-drop" // one of 'create', 'create-drop','update'
}

What this does is automatically drop and re-create the database tables on each restart of the application. Obviously this may not be what you want in production or a test server.

Grails – generate Web database application

Start WASCE Derby database server
In Explorer, browse to the root lab folder ( c:\ebtnoweos )

> click wcestart.bat
< WebSphere application server (WAS) starts running after a few minutes
a Dos command window opens with a server startup message

You can open a Web browser on the WAS server by clicking:

http://localhost:8080

Click on the Administrative console to login as the administrator

When prompted for a user id and password,
user = system
password = manager
< the WAS admin console is shown

At the end of the lab, you can click the Shutdown button to shutdown your WAS server

create a Grails application from the cmd line

Click Start > Run > type cmd > Ok
< a DOS cmd shell window opens
Type 'cd \ebtnoweos' to change to the root lab directory
> Type 'setgrails.bat'
< this sets the grails runtime environment

Type 'cd grails'
< you're in the grails app directory

create a grails application: qwex1

At the prompt, Type
'grails create-app qwex1'

< grails generates a basic Web application
change to the application directory
Type 'cd qwex1'

Note: IF you have a grails compile error on any step, always run 'grails test clean' before doing
anything else!

Replace the datasource.groovy config file

The generated datasource.groovy config file is not configured for the Derby database running in WAS CE.

You will copy another datasource.groovy config file replacing the one generated in your application folder.

In Explorer, browse to the C:\ebtnoweos\savedata\grails folder.
Select the datasource.groovy file > right button menu > copy
Browse to the conf folder in your application: C:\ebtnoweos\grails\qwex1\grails-app\conf
> Click on the folder ( not a file )
> right button menu (RBM) > select paste > when prompted say yes to replace the existing file
You've used a new datasource.groovy file that can now connect to the WAS CE Derby database

create an Author domain entity

In the DOS cmd shell, type 'dir' to ensure you are in the grails application folder ( C:\ebtnoweos\grails\
qwex1).
> Type 'grails test create-domain-class author'
< grails generates a Author entity

Edit the Author to add domain attributes

Using grails console, we'll edit the author to add attributes ( fields and methods )
Type 'grails test console'
Grails opens the console in the test environment
> File > Open > select the author.groovy file > Open
< the author.groovy file is loaded into the console editor

You'll add the code shown below in the editor

class Author {
static constraints = {
}
String lastname
String firstname
String email
String phone
}
Do NOT make punctation mistakes on the “ { ) etc

> Click File > Exit to leave the console
< when prompted to save the file, click Yes
The updated Author entity is saved

Generate the Author controller and Web views

Type 'grails test generate-all author'

< grails generates the Author Web views and controller

create a Book domain entity

In the DOS cmd shell, type 'dir' to ensure you are in the grails application folder ( C:\ebtnoweos\grails\
qwex1).
> Type 'grails test create-domain-class book'
< grails generates a Book entity

Edit the Book to add domain attributes

Using grails console, we'll edit the book to add attributes ( fields and methods )
Type 'grails test console'
Grails opens the console in the test environment
> File > Open > select the book.groovy file > Open
< the book.groovy file is loaded into the console editor

You'll add the code shown below in the editor

class Book {
static constraints = {
}
String title
String publisher
BigDecimal price
String publishDate
Author author
}

Do NOT make punctation mistakes on the “ { ) etc
> Click File > Exit to leave the console
< when prompted to save the file, click Yes

The updated Book entity is saved
If the console reopens empty, just click File > Exit
> when prompted to save, click No
You're back at the cmd shell

Generate the Book controller and Web views

Type 'grails test generate-all book'

< grails generates the Book Web views and controller

run your grails application

At the cmd prompt, type 'grails test run-app'
< the internal Jetty application server starts running
wait until you see the server is running message below

Open a Web browser and go to the application URL

http://localhost:9080/qwex1

< the browser opens to the main page of your application

Edit the Author information as needed

Click the Author list to see the full list of authors
Click Home to return to the main application screen with all the controllers
Edit the Book information as needed
Click the Book Controller
< the Book editor opens
< click New book to create a new book

Notice the first field has a drop down list box to select an author.
In a more advanced lab we'll show you how to display the author's name in the listbox not just the id
The list shows all the books you've entered:

Congratulations – you've built a Web database application in 1 hour!

Simple Grails CRUD app on Grails 2x

User

EBC

Account

Device 

Location

Energy

Steps after Grails setup

grails createApp  gtcrud1

cd gtcrud1

grails console

• add the application folder to the grails path in the console

Step-by-step guide for Example

sample code block

Recommended Next Steps

Related articles