Example usage for org.hibernate.tool.schema TargetType SCRIPT

List of usage examples for org.hibernate.tool.schema TargetType SCRIPT

  1. HOME
  2. Java
  3. org.hibernate
  4. org.hibernate.tool.schema.*
  5. TargetType
  6. SCRIPT

Introduction

In this page you can find the example usage for org.hibernate.tool.schema TargetType SCRIPT.

Prototype

TargetType SCRIPT

To view the source code for org.hibernate.tool.schema TargetType SCRIPT.

Click Source Link

Document

Write to a script file.

Usage

From source file:com.evolveum.midpoint.repo.sql.SchemaTest.java

License:Apache License

private void createSQLSchema(String fileName, String dialect) {
    File file = new File(fileName);
    if (file.exists()) {
        file.delete();/*from   w ww .  j  av a  2  s. co m*/
    }

    MetadataSources metadata = new MetadataSources(new StandardServiceRegistryBuilder()
            .applySetting("hibernate.implicit_naming_strategy", new MidPointImplicitNamingStrategy())
            .applySetting("hibernate.physical_naming_strategy", new MidPointPhysicalNamingStrategy())
            .applySetting("hibernate.dialect", dialect).build());

    addAnnotatedClasses("com.evolveum.midpoint.repo.sql.data.common", metadata);
    addAnnotatedClasses("com.evolveum.midpoint.repo.sql.data.common.container", metadata);
    addAnnotatedClasses("com.evolveum.midpoint.repo.sql.data.common.any", metadata);
    addAnnotatedClasses("com.evolveum.midpoint.repo.sql.data.common.embedded", metadata);
    addAnnotatedClasses("com.evolveum.midpoint.repo.sql.data.common.enums", metadata);
    addAnnotatedClasses("com.evolveum.midpoint.repo.sql.data.common.id", metadata);
    addAnnotatedClasses("com.evolveum.midpoint.repo.sql.data.common.other", metadata);
    addAnnotatedClasses("com.evolveum.midpoint.repo.sql.data.common.type", metadata);
    addAnnotatedClasses("com.evolveum.midpoint.repo.sql.data.audit", metadata);

    metadata.addPackage("com.evolveum.midpoint.repo.sql.type");

    SchemaExport export = new SchemaExport();
    export.setOutputFile(fileName);
    export.setDelimiter(";");
    //        export.setFormat(true);
    export.execute(EnumSet.of(TargetType.SCRIPT), SchemaExport.Action.CREATE, metadata.buildMetadata());
}

From source file:com.foilen.smalltools.tools.Hibernate51Tools.java

License:Open Source License

/**
 * Generate the SQL file. This is based on the code in {@link LocalSessionFactoryBuilder#scanPackages(String...)}
 *
 * @param dialect/*from   ww  w.  ja  v  a2  s .c om*/
 *            the dialect (e.g: org.hibernate.dialect.MySQL5InnoDBDialect )
 * @param outputSqlFile
 *            where to put the generated SQL file
 * @param useUnderscore
 *            true: to have tables names like "employe_manager" ; false: to have tables names like "employeManager"
 * @param packagesToScan
 *            the packages where your entities are
 */
public static void generateSqlSchema(Class<? extends Dialect> dialect, String outputSqlFile,
        boolean useUnderscore, String... packagesToScan) {

    BootstrapServiceRegistry bootstrapServiceRegistry = new BootstrapServiceRegistryBuilder().build();

    MetadataSources metadataSources = new MetadataSources(bootstrapServiceRegistry);

    ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(
            false);
    scanner.addIncludeFilter(new AnnotationTypeFilter(Entity.class));
    scanner.addIncludeFilter(new AnnotationTypeFilter(Embeddable.class));
    scanner.addIncludeFilter(new AnnotationTypeFilter(MappedSuperclass.class));
    for (String pkg : packagesToScan) {
        for (BeanDefinition beanDefinition : scanner.findCandidateComponents(pkg)) {
            metadataSources.addAnnotatedClassName(beanDefinition.getBeanClassName());
        }
    }

    StandardServiceRegistryBuilder standardServiceRegistryBuilder = new StandardServiceRegistryBuilder(
            bootstrapServiceRegistry);
    standardServiceRegistryBuilder.applySetting(AvailableSettings.DIALECT, dialect.getName());
    StandardServiceRegistryImpl ssr = (StandardServiceRegistryImpl) standardServiceRegistryBuilder.build();
    MetadataBuilder metadataBuilder = metadataSources.getMetadataBuilder(ssr);

    if (useUnderscore) {
        metadataBuilder.applyImplicitNamingStrategy(new SpringImplicitNamingStrategy());
        metadataBuilder.applyPhysicalNamingStrategy(new SpringPhysicalNamingStrategy());
    }

    new SchemaExport() //
            .setHaltOnError(true) //
            .setOutputFile(outputSqlFile) //
            .setFormat(true) //
            .setDelimiter(";") //
            .execute(EnumSet.of(TargetType.SCRIPT), SchemaExport.Action.CREATE, metadataBuilder.build());

}

From source file:com.imos.sample.service.HibernateService.java

/**
 * Hibernate configuration.//  ww  w.  ja va  2  s  .com
 *
 * @throws RepositoryException
 */
public void config() throws RepositoryException {
    try {
        StandardServiceRegistryBuilder registryBuilder = new StandardServiceRegistryBuilder();
        if (filePath == null || filePath.isEmpty()) {
            registryBuilder = registryBuilder.configure();
        } else {
            registryBuilder = registryBuilder.configure(filePath);
        }
        registry = registryBuilder.build();

        MetadataSources metaData = new MetadataSources(registry);
        sessionFactory = metaData.buildMetadata().buildSessionFactory();
        session = sessionFactory.openSession();

        SchemaExport schemaExport = new SchemaExport();
        schemaExport.setDelimiter(";");
        schemaExport.setFormat(true);
        schemaExport.setManageNamespaces(true);
        schemaExport.setOutputFile("./ddl_skilldb.sql");
        schemaExport.execute(EnumSet.of(TargetType.SCRIPT, TargetType.DATABASE, TargetType.STDOUT),
                SchemaExport.Action.CREATE, metaData.buildMetadata(registry), registry);

        log.info("Configuration succeed");
    } catch (HibernateException e) {
        StandardServiceRegistryBuilder.destroy(registry);
        log.error("Configuration failed : {}", e);
    }
}

From source file:com.oneandone.relesia.tools.SQLScriptGenerator.java

License:Apache License

public static void main(String[] args) throws MappingException, IOException {

    String createSQLFile = "dbscripts/createTables.sql";
    String dropSQLFile = "dbscripts/dropTables.sql";
    String hibernateCfgFile = "/db/hibernate.cfg.xml";

    final EnumSet<TargetType> targetTypes = EnumSet.noneOf(TargetType.class);
    targetTypes.add(TargetType.SCRIPT);

    System.out.println("Initialize Hibernate configuration from " + hibernateCfgFile);

    Configuration cfg = new Configuration().configure(hibernateCfgFile);
    Metadata metadata = MetadataHelper.getMetadata(cfg);

    SchemaExport export = new SchemaExport();
    export.setHaltOnError(true);//from w  w  w  .  j a  va2  s . c o m
    export.setFormat(true);
    export.setDelimiter(";");

    System.out.println("Generating create SQL to file " + createSQLFile);
    if (new File(createSQLFile).exists()) {
        Files.delete(Paths.get(createSQLFile));
    }
    export.setOutputFile(createSQLFile);
    export.execute(targetTypes, Action.CREATE, metadata);

    System.out.println("Generating drop SQL to file " + dropSQLFile);
    export.setOutputFile(dropSQLFile);
    if (new File(dropSQLFile).exists()) {
        Files.delete(Paths.get(dropSQLFile));
    }
    export.execute(targetTypes, Action.DROP, metadata);

    System.out.println("Done!");
}

From source file:de.jpdigital.maven.plugins.hibernate5ddl.GenerateDdlMojo.java

License:Open Source License

/**
 * Helper method for generating the DDL classes for a specific dialect. This
 * is place for the real work is done. The method first creates an instance
 * of the {@link Configuration} class from Hibernate an puts the appropriate
 * values into it. It then creates an instance of the {@link SchemaExport}
 * class from the Hibernate API, configured this class, for example by
 * setting {@code format} to {@code true} so that the generated SQL files
 * are formatted nicely. After that it calls the
 * {@link SchemaExport#execute(boolean, boolean, boolean, boolean)} method
 * which will create the SQL script file. The method is called in a way
 * which requires <em>no</em> database connection.
 *
 *
 * @param dialect       The dialect for which the DDL files is generated.
 * @param entityClasses The entity classes for which the DDL file is
 *                      generated./* w w  w  . ja  v a  2s  . c  o m*/
 *
 * @throws MojoFailureException if something goes wrong.
 */
private void generateDdl(final Dialect dialect, final Set<Class<?>> entityClasses) throws MojoFailureException {

    final StandardServiceRegistryBuilder registryBuilder = new StandardServiceRegistryBuilder();
    processPersistenceXml(registryBuilder);

    if (createDropStatements) {
        registryBuilder.applySetting("hibernate.hbm2ddl.auto", "create-drop");
    } else {
        registryBuilder.applySetting("hibernate.hbm2ddl.auto", "create");
    }

    registryBuilder.applySetting("hibernate.dialect", dialect.getDialectClass());

    final StandardServiceRegistry standardRegistry = registryBuilder.build();

    final MetadataSources metadataSources = new MetadataSources(standardRegistry);

    for (final Class<?> entityClass : entityClasses) {
        metadataSources.addAnnotatedClass(entityClass);
    }

    final SchemaExport export = new SchemaExport();
    //        final SchemaExport export = new SchemaExport(
    //            (MetadataImplementor) metadata, true);
    export.setDelimiter(";");

    final Path tmpDir;
    try {
        tmpDir = Files.createTempDirectory("maven-hibernate5-ddl-plugin");
    } catch (IOException ex) {
        throw new MojoFailureException("Failed to create work dir.", ex);
    }

    final Metadata metadata = metadataSources.buildMetadata();

    export.setOutputFile(
            String.format("%s/%s.sql", tmpDir.toString(), dialect.name().toLowerCase(Locale.ENGLISH)));
    export.setFormat(true);
    if (createDropStatements) {
        export.execute(EnumSet.of(TargetType.SCRIPT), SchemaExport.Action.BOTH, metadata);
    } else {
        export.execute(EnumSet.of(TargetType.SCRIPT), SchemaExport.Action.CREATE, metadata);
    }

    writeOutputFile(dialect, tmpDir);
}

From source file:org.geosdi.geoplatform.persistence.configuration.properties.export.GPTargetTypeConfig.java

License:Open Source License

@Bean
public static TargetType gpTargetType(
        @Value("persistence{schema_export_target_type:@null}") String targetType) {
    return ((targetType != null) && !(targetType.isEmpty()) ? buildTargetType(targetType) : TargetType.SCRIPT);
}

From source file:org.geosdi.geoplatform.persistence.configuration.properties.export.GPTargetTypeConfig.java

License:Open Source License

static TargetType buildTargetType(String source) {
    for (TargetType targetType : TargetType.values()) {
        if (targetType.name().equalsIgnoreCase(source)) {
            return targetType;
        }/*from  www.ja  va 2 s.com*/
    }
    return TargetType.SCRIPT;
}

From source file:org.springframework.cloud.dataflow.server.repository.SchemaGenerationTests.java

License:Apache License

private void generateDdlFiles(String dialect, File tempDir, PersistenceUnitInfo persistenceUnitInfo) {
    logger.info("Generating DDL script for " + dialect);

    final MetadataSources metadata = new MetadataSources(new StandardServiceRegistryBuilder()
            .applySetting("hibernate.dialect", "org.hibernate.dialect." + dialect + "Dialect")
            .applySetting("hibernate.physical_naming_strategy", SpringPhysicalNamingStrategy.class.getName())
            .applySetting("hibernate.implicit_naming_strategy", SpringImplicitNamingStrategy.class.getName())
            .build());/*from ww w  . j  a  v  a2 s.c  om*/

    for (String clazz : persistenceUnitInfo.getManagedClassNames()) {
        logger.info(clazz);
        metadata.addAnnotatedClassName(clazz);
    }

    final SchemaExport export;
    try {
        export = new SchemaExport();
        export.setDelimiter(";");
        export.setFormat(true);
        export.setOutputFile(new File(tempDir, "schema-" + dialect.toLowerCase() + ".sql").getAbsolutePath());
    } catch (HibernateException e) {
        throw new IllegalStateException(e);
    }
    EnumSet<TargetType> targetTypes = EnumSet.of(TargetType.SCRIPT);
    export.execute(targetTypes, SchemaExport.Action.BOTH, metadata.buildMetadata());
}