Example usage for org.hibernate.tool.hbm2ddl Target SCRIPT

List of usage examples for org.hibernate.tool.hbm2ddl Target SCRIPT

  1. HOME
  2. Java
  3. org.hibernate
  4. org.hibernate.tool.hbm2ddl.*
  5. Target
  6. SCRIPT

Introduction

In this page you can find the example usage for org.hibernate.tool.hbm2ddl Target SCRIPT.

Prototype

Target SCRIPT

To view the source code for org.hibernate.tool.hbm2ddl Target SCRIPT.

Click Source Link

Document

Write to a script file.

Usage

From source file:de.juplo.plugins.hibernate4.Hbm2DdlMojo.java

License:Apache License

@Override
public void execute() throws MojoFailureException, MojoExecutionException {
    if (skip) {/*from w ww  . j  av  a  2s.  co  m*/
        getLog().info("Exectuion of hibernate4-maven-plugin:export was skipped!");
        project.getProperties().setProperty(EXPORT_SKIPPED_PROPERTY, "true");
        return;
    }

    File dir = new File(outputDirectory);
    if (!dir.exists())
        throw new MojoExecutionException(
                "Cannot scan for annotated classes in " + outputDirectory + ": directory does not exist!");

    Map<String, String> md5s;
    boolean modified = false;
    File saved = new File(buildDirectory + File.separator + MD5S);

    if (saved.exists()) {
        try {
            FileInputStream fis = new FileInputStream(saved);
            ObjectInputStream ois = new ObjectInputStream(fis);
            md5s = (HashMap<String, String>) ois.readObject();
            ois.close();
        } catch (Exception e) {
            md5s = new HashMap<String, String>();
            getLog().warn("Cannot read timestamps from saved: " + e);
        }
    } else {
        md5s = new HashMap<String, String>();
        try {
            saved.createNewFile();
        } catch (IOException e) {
            getLog().warn("Cannot create saved for timestamps: " + e);
        }
    }

    ClassLoader classLoader = null;
    try {
        getLog().debug("Creating ClassLoader for project-dependencies...");
        List<String> classpathFiles = project.getCompileClasspathElements();
        if (scanTestClasses)
            classpathFiles.addAll(project.getTestClasspathElements());
        URL[] urls = new URL[classpathFiles.size()];
        for (int i = 0; i < classpathFiles.size(); ++i) {
            getLog().debug("Dependency: " + classpathFiles.get(i));
            urls[i] = new File(classpathFiles.get(i)).toURI().toURL();
        }
        classLoader = new URLClassLoader(urls, getClass().getClassLoader());
    } catch (Exception e) {
        getLog().error("Error while creating ClassLoader!", e);
        throw new MojoExecutionException(e.getMessage());
    }

    Set<Class<?>> classes = new TreeSet<Class<?>>(new Comparator<Class<?>>() {
        @Override
        public int compare(Class<?> a, Class<?> b) {
            return a.getName().compareTo(b.getName());
        }
    });

    try {
        AnnotationDB db = new AnnotationDB();
        getLog().info("Scanning directory " + outputDirectory + " for annotated classes...");
        URL dirUrl = dir.toURI().toURL();
        db.scanArchives(dirUrl);
        if (scanTestClasses) {
            dir = new File(testOutputDirectory);
            if (!dir.exists())
                throw new MojoExecutionException("Cannot scan for annotated test-classes in "
                        + testOutputDirectory + ": directory does not exist!");
            getLog().info("Scanning directory " + testOutputDirectory + " for annotated classes...");
            dirUrl = dir.toURI().toURL();
            db.scanArchives(dirUrl);
        }

        Set<String> classNames = new HashSet<String>();
        if (db.getAnnotationIndex().containsKey(Entity.class.getName()))
            classNames.addAll(db.getAnnotationIndex().get(Entity.class.getName()));
        if (db.getAnnotationIndex().containsKey(MappedSuperclass.class.getName()))
            classNames.addAll(db.getAnnotationIndex().get(MappedSuperclass.class.getName()));
        if (db.getAnnotationIndex().containsKey(Embeddable.class.getName()))
            classNames.addAll(db.getAnnotationIndex().get(Embeddable.class.getName()));

        MessageDigest digest = java.security.MessageDigest.getInstance("MD5");
        for (String name : classNames) {
            Class<?> annotatedClass = classLoader.loadClass(name);
            classes.add(annotatedClass);
            InputStream is = annotatedClass.getResourceAsStream(annotatedClass.getSimpleName() + ".class");
            byte[] buffer = new byte[1024 * 4]; // copy data in 4MB-chunks
            int i;
            while ((i = is.read(buffer)) > -1)
                digest.update(buffer, 0, i);
            is.close();
            byte[] bytes = digest.digest();
            BigInteger bi = new BigInteger(1, bytes);
            String newMd5 = String.format("%0" + (bytes.length << 1) + "x", bi);
            String oldMd5 = !md5s.containsKey(name) ? "" : md5s.get(name);
            if (!newMd5.equals(oldMd5)) {
                getLog().debug("Found new or modified annotated class: " + name);
                modified = true;
                md5s.put(name, newMd5);
            } else {
                getLog().debug(oldMd5 + " -> class unchanged: " + name);
            }
        }
    } catch (ClassNotFoundException e) {
        getLog().error("Error while adding annotated classes!", e);
        throw new MojoExecutionException(e.getMessage());
    } catch (Exception e) {
        getLog().error("Error while scanning!", e);
        throw new MojoFailureException(e.getMessage());
    }

    if (classes.isEmpty())
        throw new MojoFailureException("No annotated classes found in directory " + outputDirectory);

    getLog().debug("Detected classes with mapping-annotations:");
    for (Class<?> annotatedClass : classes)
        getLog().debug("  " + annotatedClass.getName());

    Properties properties = new Properties();

    /** Try to read configuration from properties-file */
    try {
        File file = new File(hibernateProperties);
        if (file.exists()) {
            getLog().info("Reading properties from file " + hibernateProperties + "...");
            properties.load(new FileInputStream(file));
        } else
            getLog().info("No hibernate-properties-file found! (Checked path: " + hibernateProperties + ")");
    } catch (IOException e) {
        getLog().error("Error while reading properties!", e);
        throw new MojoExecutionException(e.getMessage());
    }

    /** Overwrite values from propertie-file or set, if given */
    if (driverClassName != null) {
        if (properties.containsKey(DRIVER_CLASS))
            getLog().debug("Overwriting property " + DRIVER_CLASS + "=" + properties.getProperty(DRIVER_CLASS)
                    + " with the value " + driverClassName);
        else
            getLog().debug("Using the value " + driverClassName);
        properties.setProperty(DRIVER_CLASS, driverClassName);
    }
    if (url != null) {
        if (properties.containsKey(URL))
            getLog().debug("Overwriting property " + URL + "=" + properties.getProperty(URL)
                    + " with the value " + url);
        else
            getLog().debug("Using the value " + url);
        properties.setProperty(URL, url);
    }
    if (username != null) {
        if (properties.containsKey(USERNAME))
            getLog().debug("Overwriting property " + USERNAME + "=" + properties.getProperty(USERNAME)
                    + " with the value " + username);
        else
            getLog().debug("Using the value " + username);
        properties.setProperty(USERNAME, username);
    }
    if (password != null) {
        if (properties.containsKey(PASSWORD))
            getLog().debug("Overwriting property " + PASSWORD + "=" + properties.getProperty(PASSWORD)
                    + " with the value " + password);
        else
            getLog().debug("Using the value " + password);
        properties.setProperty(PASSWORD, password);
    }
    if (hibernateDialect != null) {
        if (properties.containsKey(DIALECT))
            getLog().debug("Overwriting property " + DIALECT + "=" + properties.getProperty(DIALECT)
                    + " with the value " + hibernateDialect);
        else
            getLog().debug("Using the value " + hibernateDialect);
        properties.setProperty(DIALECT, hibernateDialect);
    }
    if (hibernateNamingStrategy != null) {
        if (properties.contains(NAMING_STRATEGY))
            getLog().debug("Overwriting property " + NAMING_STRATEGY + "="
                    + properties.getProperty(NAMING_STRATEGY) + " with the value " + hibernateNamingStrategy);
        else
            getLog().debug("Using the value " + hibernateNamingStrategy);
        properties.setProperty(NAMING_STRATEGY, hibernateNamingStrategy);
    }

    /** The generated SQL varies with the dialect! */
    if (md5s.containsKey(DIALECT)) {
        String dialect = properties.getProperty(DIALECT);
        if (md5s.get(DIALECT).equals(dialect))
            getLog().debug("SQL-dialect unchanged.");
        else {
            getLog().debug("SQL-dialect changed: " + dialect);
            modified = true;
            md5s.put(DIALECT, dialect);
        }
    } else {
        modified = true;
        md5s.put(DIALECT, properties.getProperty(DIALECT));
    }

    if (properties.isEmpty()) {
        getLog().error("No properties set!");
        throw new MojoFailureException("Hibernate-Configuration is missing!");
    }

    Configuration config = new Configuration();
    config.setProperties(properties);

    if (properties.containsKey(NAMING_STRATEGY)) {
        String namingStrategy = properties.getProperty(NAMING_STRATEGY);
        getLog().debug("Explicitly set NamingStrategy: " + namingStrategy);
        try {
            @SuppressWarnings("unchecked")
            Class<NamingStrategy> namingStrategyClass = (Class<NamingStrategy>) Class.forName(namingStrategy);
            config.setNamingStrategy(namingStrategyClass.newInstance());
        } catch (Exception e) {
            getLog().error("Error setting NamingStrategy", e);
            throw new MojoExecutionException(e.getMessage());
        }
    }

    getLog().debug("Adding annotated classes to hibernate-mapping-configuration...");
    for (Class<?> annotatedClass : classes) {
        getLog().debug("Class " + annotatedClass);
        config.addAnnotatedClass(annotatedClass);
    }

    Target target = null;
    try {
        target = Target.valueOf(this.target.toUpperCase());
    } catch (IllegalArgumentException e) {
        getLog().error("Invalid value for configuration-option \"target\": " + this.target);
        getLog().error("Valid values are: NONE, SCRIPT, EXPORT, BOTH");
        throw new MojoExecutionException("Invalid value for configuration-option \"target\"");
    }
    Type type = null;
    try {
        type = Type.valueOf(this.type.toUpperCase());
    } catch (IllegalArgumentException e) {
        getLog().error("Invalid value for configuration-option \"type\": " + this.type);
        getLog().error("Valid values are: NONE, CREATE, DROP, BOTH");
        throw new MojoExecutionException("Invalid value for configuration-option \"type\"");
    }

    if (target.equals(Target.SCRIPT) || target.equals(Target.NONE)) {
        project.getProperties().setProperty(EXPORT_SKIPPED_PROPERTY, "true");
    }
    if (!modified && !target.equals(Target.SCRIPT) && !target.equals(Target.NONE) && !force) {
        getLog().info("No modified annotated classes found and dialect unchanged.");
        getLog().info("Skipping schema generation!");
        project.getProperties().setProperty(EXPORT_SKIPPED_PROPERTY, "true");
        return;
    }

    getLog().info("Gathered hibernate-configuration (turn on debugging for details):");
    for (Entry<Object, Object> entry : properties.entrySet())
        getLog().info("  " + entry.getKey() + " = " + entry.getValue());

    Connection connection = null;
    try {
        /**
         * The connection must be established outside of hibernate, because
         * hibernate does not use the context-classloader of the current
         * thread and, hence, would not be able to resolve the driver-class!
         */
        switch (target) {
        case EXPORT:
        case BOTH:
            switch (type) {
            case CREATE:
            case DROP:
            case BOTH:
                Class driverClass = classLoader.loadClass(properties.getProperty(DRIVER_CLASS));
                getLog().debug("Registering JDBC-driver " + driverClass.getName());
                DriverManager.registerDriver(new DriverProxy((Driver) driverClass.newInstance()));
                getLog().debug("Opening JDBC-connection to " + properties.getProperty(URL) + " as "
                        + properties.getProperty(USERNAME) + " with password "
                        + properties.getProperty(PASSWORD));
                connection = DriverManager.getConnection(properties.getProperty(URL),
                        properties.getProperty(USERNAME), properties.getProperty(PASSWORD));
            }
        }
    } catch (ClassNotFoundException e) {
        getLog().error("Dependency for driver-class " + properties.getProperty(DRIVER_CLASS) + " is missing!");
        throw new MojoExecutionException(e.getMessage());
    } catch (Exception e) {
        getLog().error("Cannot establish connection to database!");
        Enumeration<Driver> drivers = DriverManager.getDrivers();
        if (!drivers.hasMoreElements())
            getLog().error("No drivers registered!");
        while (drivers.hasMoreElements())
            getLog().debug("Driver: " + drivers.nextElement());
        throw new MojoExecutionException(e.getMessage());
    }

    ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
    MavenLogAppender.startPluginLog(this);
    try {
        /**
         * Change class-loader of current thread, so that hibernate can
         * see all dependencies!
         */
        Thread.currentThread().setContextClassLoader(classLoader);

        SchemaExport export = new SchemaExport(config, connection);
        export.setOutputFile(outputFile);
        export.setDelimiter(delimiter);
        export.setFormat(format);
        export.execute(target, type);

        for (Object exception : export.getExceptions())
            getLog().debug(exception.toString());
    } finally {
        /** Stop Log-Capturing */
        MavenLogAppender.endPluginLog(this);

        /** Restore the old class-loader (TODO: is this really necessary?) */
        Thread.currentThread().setContextClassLoader(contextClassLoader);

        /** Close the connection */
        try {
            if (connection != null)
                connection.close();
        } catch (SQLException e) {
            getLog().error("Error while closing connection: " + e.getMessage());
        }
    }

    /** Write md5-sums for annotated classes to file */
    try {
        FileOutputStream fos = new FileOutputStream(saved);
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(md5s);
        oos.close();
        fos.close();
    } catch (Exception e) {
        getLog().error("Cannot write md5-sums to file: " + e);
    }
}

From source file:io.github.jonestimd.finance.dao.HibernateDaoContext.java

License:Open Source License

public static void main(String[] args) {
    try {/*from  w  w  w. j a  v  a2  s.  c o  m*/
        DriverService driverService = CONNECTION_CONFIG.loadDriver();
        HibernateDaoContext context = new HibernateDaoContext(driverService, ApplicationConfig.CONFIG);
        //            Stream.of(context.schemaCreationScript()).forEach(System.out::println);
        new SchemaUpdate(context.configuration).execute(Target.SCRIPT);
    } catch (Exception ex) {
        ex.printStackTrace();
    }
}

From source file:org.jahia.maven.hbm2ddl.JpaSchemaExportMojo.java

License:Open Source License

private void performExport() throws MojoExecutionException {
    final Configuration cfg = new Ejb3Configuration().configure(persistenceUnitName, getHibernateProperties())
            .getHibernateConfiguration();

    configureNamingStrategy(cfg);//from w w  w  .  j ava2 s.c  o  m

    SchemaExport schemaExport = new SchemaExport(cfg);
    schemaExport.setDelimiter(";");
    schemaExport.setOutputFile(outputFile.getAbsolutePath());
    schemaExport.execute(Target.SCRIPT, statementType);
}