Author: steve.ebersole@(protected)
Date: 2008-10-13 11:29:23 -0400 (Mon, 13 Oct 2008)
New Revision: 15343

Added:
 core/trunk/core/src/main/java/org/hibernate/dialect/resolver/
 core/trunk/core/src/main/java/org/hibernate/dialect/resolver/AbstractDialectResolver.java
 core/trunk/core/src/main/java/org/hibernate/dialect/resolver/BasicDialectResolver.java
 core/trunk/core/src/main/java/org/hibernate/dialect/resolver/BasicSQLExceptionConverter.java
 core/trunk/core/src/main/java/org/hibernate/dialect/resolver/DialectFactory.java
 core/trunk/core/src/main/java/org/hibernate/dialect/resolver/DialectResolver.java
 core/trunk/core/src/main/java/org/hibernate/dialect/resolver/DialectResolverSet.java
 core/trunk/core/src/main/java/org/hibernate/dialect/resolver/StandardDialectResolver.java
 core/trunk/core/src/test/java/org/hibernate/dialect/
 core/trunk/core/src/test/java/org/hibernate/dialect/Mocks.java
 core/trunk/core/src/test/java/org/hibernate/dialect/TestingDialects.java
 core/trunk/core/src/test/java/org/hibernate/dialect/resolver/
 core/trunk/core/src/test/java/org/hibernate/dialect/resolver/DialectFactoryTest.java
 core/trunk/core/src/test/java/org/hibernate/dialect/resolver/DialectResolverTest.java
 core/trunk/core/src/test/resources/
 core/trunk/core/src/test/resources/log4j.properties
Removed:
 core/trunk/core/src/main/java/org/hibernate/dialect/DialectFactory.java
Modified:
 core/trunk/core/src/main/java/org/hibernate/cfg/Environment.java
 core/trunk/core/src/main/java/org/hibernate/cfg/SettingsFactory.java
Log:
HHH-2293 : DialectResolver

Modified: core/trunk/core/src/main/java/org/hibernate/cfg/Environment.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/cfg/Environment.java  2008-10-13 15:16:21 UTC (rev 15342)
+++ core/trunk/core/src/main/java/org/hibernate/cfg/Environment.java  2008-10-13 15:29:23 UTC (rev 15343)
@@(protected) @@
  * Hibernate SQL {@(protected)
  */
 public static final String DIALECT ="hibernate.dialect";
+
 /**
+   * {@(protected)
+   * {@(protected)}
+   */
+  public static final String DIALECT_RESOLVERS = "hibernate.dialect_resolvers";
+
+  /**
  * A default database schema (owner) name to use for unqualified tablenames
  */
 public static final String DEFAULT_SCHEMA = "hibernate.default_schema";

Modified: core/trunk/core/src/main/java/org/hibernate/cfg/SettingsFactory.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/cfg/SettingsFactory.java  2008-10-13 15:16:21 UTC (rev 15342)
+++ core/trunk/core/src/main/java/org/hibernate/cfg/SettingsFactory.java  2008-10-13 15:29:23 UTC (rev 15343)
@@(protected) @@
package org.hibernate.cfg;

import java.io.Serializable;
-import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.ResultSet;
@@(protected) @@
import org.hibernate.connection.ConnectionProvider;
import org.hibernate.connection.ConnectionProviderFactory;
import org.hibernate.dialect.Dialect;
-import org.hibernate.dialect.DialectFactory;
+import org.hibernate.dialect.resolver.DialectFactory;
import org.hibernate.exception.SQLExceptionConverter;
import org.hibernate.exception.SQLExceptionConverterFactory;
import org.hibernate.hql.QueryTranslatorFactory;
@@(protected) @@
import org.hibernate.util.StringHelper;

/**
- * Reads configuration properties and configures a <tt>Settings</tt> instance.
+ * Reads configuration properties and builds a {@(protected).
*
* @author Gavin King
*/
public class SettingsFactory implements Serializable {
+  private static final Logger log = LoggerFactory.getLogger( SettingsFactory.class );
+  private static final long serialVersionUID = -1194386144994524825L;

 public static final String DEF_CACHE_REG_FACTORY = NoCachingRegionFactory.class.getName();
-  private static final Logger log = LoggerFactory.getLogger(SettingsFactory.class);

 protected SettingsFactory() {
 }
-  
+
 public Settings buildSettings(Properties props) {
   Settings settings = new Settings();
-    
+
   //SessionFactory name:
-    
+
   String sessionFactoryName = props.getProperty(Environment.SESSION_FACTORY_NAME);
   settings.setSessionFactoryName(sessionFactoryName);

@@(protected) @@

   //Interrogate JDBC metadata

-    String databaseName = null;
-    int databaseMajorVersion = 0;
   boolean metaSupportsScrollable = false;
   boolean metaSupportsGetGeneratedKeys = false;
   boolean metaSupportsBatchUpdates = false;
   boolean metaReportsDDLCausesTxnCommit = false;
   boolean metaReportsDDLInTxnSupported = true;
+    Dialect dialect = null;

   // 'hibernate.temp.use_jdbc_metadata_defaults' is a temporary magic value.
-    // The need for it is intended to be alleviated with 3.3 developement, thus it is
+    // The need for it is intended to be alleviated with future developement, thus it is
   // not defined as an Environment constant...
+    //
   // it is used to control whether we should consult the JDBC metadata to determine
   // certain Settings default values; it is useful to *not* do this when the database
   // may not be available (mainly in tools usage).
@@(protected) @@
       Connection conn = connections.getConnection();
       try {
         DatabaseMetaData meta = conn.getMetaData();
-          databaseName = meta.getDatabaseProductName();
-          databaseMajorVersion = getDatabaseMajorVersion(meta);
-          log.info("RDBMS: " + databaseName + ", version: " + meta.getDatabaseProductVersion() );
-          log.info("JDBC driver: " + meta.getDriverName() + ", version: " + meta.getDriverVersion() );
+          log.info( "RDBMS: " + meta.getDatabaseProductName() + ", version: " + meta.getDatabaseProductVersion() );
+          log.info( "JDBC driver: " + meta.getDriverName() + ", version: " + meta.getDriverVersion() );

-          metaSupportsScrollable = meta.supportsResultSetType(ResultSet.TYPE_SCROLL_INSENSITIVE);
+          dialect = DialectFactory.buildDialect( props, conn );
+
+          metaSupportsScrollable = meta.supportsResultSetType( ResultSet.TYPE_SCROLL_INSENSITIVE );
         metaSupportsBatchUpdates = meta.supportsBatchUpdates();
         metaReportsDDLCausesTxnCommit = meta.dataDefinitionCausesTransactionCommit();
         metaReportsDDLInTxnSupported = !meta.dataDefinitionIgnoredInTransactions();
-          metaSupportsGetGeneratedKeys = meta.supportsGetGeneratedKeys();
+          metaSupportsGetGeneratedKeys = meta.supportsGetGeneratedKeys();
       }
-        catch (SQLException sqle) {
-          log.warn("Could not obtain connection metadata", sqle);
+        catch ( SQLException sqle ) {
+          log.warn( "Could not obtain connection metadata", sqle );
       }
       finally {
-          connections.closeConnection(conn);
+          connections.closeConnection( conn );
       }
     }
-      catch (SQLException sqle) {
-        log.warn("Could not obtain connection to query metadata", sqle);
+      catch ( SQLException sqle ) {
+        log.warn( "Could not obtain connection to query metadata", sqle );
+        dialect = DialectFactory.buildDialect( props );
     }
-      catch (UnsupportedOperationException uoe) {
+      catch ( UnsupportedOperationException uoe ) {
       // user supplied JDBC connections
+        dialect = DialectFactory.buildDialect( props );
     }
   }
+    else {
+      dialect = DialectFactory.buildDialect( props );
+    }
+
   settings.setDataDefinitionImplicitCommit( metaReportsDDLCausesTxnCommit );
   settings.setDataDefinitionInTransactionSupported( metaReportsDDLInTxnSupported );
+    settings.setDialect( dialect );

-
-    //SQL Dialect:
-    Dialect dialect = determineDialect( props, databaseName, databaseMajorVersion );
-    settings.setDialect(dialect);
-    
   //use dialect default properties
   final Properties properties = new Properties();
   properties.putAll( dialect.getDefaultProperties() );
-    properties.putAll(props);
-    
+    properties.putAll( props );
+
   // Transaction settings:
-    
+
   TransactionFactory transactionFactory = createTransactionFactory(properties);
   settings.setTransactionFactory(transactionFactory);
   settings.setTransactionManagerLookup( createTransactionManagerLookup(properties) );
@@(protected) @@
   if (batchSize>0) log.info("JDBC batch updates for versioned data: " + enabledDisabled(jdbcBatchVersionedData) );
   settings.setJdbcBatchVersionedData(jdbcBatchVersionedData);
   settings.setBatcherFactory( createBatcherFactory(properties, batchSize) );
-    
+
   boolean useScrollableResultSets = PropertiesHelper.getBoolean(Environment.USE_SCROLLABLE_RESULTSET, properties, metaSupportsScrollable);
   log.info("Scrollable result sets: " + enabledDisabled(useScrollableResultSets) );
   settings.setScrollableResultSetsEnabled(useScrollableResultSets);
@@(protected) @@
   boolean comments = PropertiesHelper.getBoolean(Environment.USE_SQL_COMMENTS, properties);
   log.info( "Generate SQL with comments: " + enabledDisabled(comments) );
   settings.setCommentsEnabled(comments);
-    
+
   boolean orderUpdates = PropertiesHelper.getBoolean(Environment.ORDER_UPDATES, properties);
   log.info( "Order SQL updates by primary key: " + enabledDisabled(orderUpdates) );
   settings.setOrderUpdatesEnabled(orderUpdates);
@@(protected) @@
   boolean orderInserts = PropertiesHelper.getBoolean(Environment.ORDER_INSERTS, properties);
   log.info( "Order SQL inserts for batching: " + enabledDisabled( orderInserts ) );
   settings.setOrderInsertsEnabled( orderInserts );
-    
+
   //Query parser settings:
-    
+
   settings.setQueryTranslatorFactory( createQueryTranslatorFactory(properties) );

   Map querySubstitutions = PropertiesHelper.toMap(Environment.QUERY_SUBSTITUTIONS, " ,=;:\n\t\r\f", properties);
@@(protected) @@
   boolean jpaqlCompliance = PropertiesHelper.getBoolean( Environment.JPAQL_STRICT_COMPLIANCE, properties, false );
   settings.setStrictJPAQLCompliance( jpaqlCompliance );
   log.info( "JPA-QL strict compliance: " + enabledDisabled( jpaqlCompliance ) );
-    
+
   // Second-level / query cache:

   boolean useSecondLevelCache = PropertiesHelper.getBoolean(Environment.USE_SECOND_LEVEL_CACHE, properties, true);
@@(protected) @@
   settings.setStructuredCacheEntriesEnabled(useStructuredCacheEntries);

   if (useQueryCache) settings.setQueryCacheFactory( createQueryCacheFactory(properties) );
-    
+
   //SQL Exception converter:
-    
+
   SQLExceptionConverter sqlExceptionConverter;
   try {
     sqlExceptionConverter = SQLExceptionConverterFactory.buildSQLExceptionConverter( dialect, properties );
@@(protected) @@
   boolean useStatistics = PropertiesHelper.getBoolean(Environment.GENERATE_STATISTICS, properties);
   log.info( "Statistics: " + enabledDisabled(useStatistics) );
   settings.setStatisticsEnabled(useStatistics);
-    
+
   boolean useIdentifierRollback = PropertiesHelper.getBoolean(Environment.USE_IDENTIFIER_ROLLBACK, properties);
   log.info( "Deleted entity synthetic identifier rollback: " + enabledDisabled(useIdentifierRollback) );
   settings.setIdentifierRollbackEnabled(useIdentifierRollback);
-    
+
   //Schema export:
-    
+
   String autoSchemaExport = properties.getProperty(Environment.HBM2DDL_AUTO);
   if ( "validate".equals(autoSchemaExport) ) settings.setAutoValidateSchema(true);
   if ( "update".equals(autoSchemaExport) ) settings.setAutoUpdateSchema(true);
@@(protected) @@
   }
 }

-  private int getDatabaseMajorVersion(DatabaseMetaData meta) {
-    try {
-      Method gdbmvMethod = DatabaseMetaData.class.getMethod("getDatabaseMajorVersion", null);
-      return ( (Integer) gdbmvMethod.invoke(meta, null) ).intValue();
-    }
-    catch (NoSuchMethodException nsme) {
-      return 0;
-    }
-    catch (Throwable t) {
-      log.debug("could not get database version from JDBC metadata");
-      return 0;
-    }
-  }
-
 private static String enabledDisabled(boolean value) {
   return value ? "enabled" : "disabled";
 }
-  
+
 protected QueryCacheFactory createQueryCacheFactory(Properties properties) {
   String queryCacheFactoryClassName = PropertiesHelper.getString(
       Environment.QUERY_CACHE_FACTORY, properties, "org.hibernate.cache.StandardQueryCacheFactory"
@@(protected) @@
     throw new HibernateException( "could not instantiate RegionFactory [" + regionFactoryClassName + "]", e );
   }
 }
-  
+
 protected QueryTranslatorFactory createQueryTranslatorFactory(Properties properties) {
   String className = PropertiesHelper.getString(
       Environment.QUERY_TRANSLATOR, properties, "org.hibernate.hql.ast.ASTQueryTranslatorFactory"
@@(protected) @@
     throw new HibernateException("could not instantiate QueryTranslatorFactory: " + className, cnfe);
   }
 }
-  
+
 protected BatcherFactory createBatcherFactory(Properties properties, int batchSize) {
   String batcherClass = properties.getProperty(Environment.BATCH_STRATEGY);
   if (batcherClass==null) {
@@(protected) @@
     }
   }
 }
-  
+
 protected ConnectionProvider createConnectionProvider(Properties properties) {
   return ConnectionProviderFactory.newConnectionProvider(properties);
 }
-  
+
 protected TransactionFactory createTransactionFactory(Properties properties) {
   return TransactionFactoryFactory.buildTransactionFactory(properties);
 }
-  
+
 protected TransactionManagerLookup createTransactionManagerLookup(Properties properties) {
-    return TransactionManagerLookupFactory.getTransactionManagerLookup(properties);    
+    return TransactionManagerLookupFactory.getTransactionManagerLookup(properties);
 }

-  private Dialect determineDialect(Properties props, String databaseName, int databaseMajorVersion) {
-    return DialectFactory.buildDialect( props, databaseName, databaseMajorVersion );
-  }
-  
}

Deleted: core/trunk/core/src/main/java/org/hibernate/dialect/DialectFactory.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/dialect/DialectFactory.java  2008-10-13 15:16:21 UTC (rev 15342)
+++ core/trunk/core/src/main/java/org/hibernate/dialect/DialectFactory.java  2008-10-13 15:29:23 UTC (rev 15343)
@@(protected) @@
-/*
- * Hibernate, Relational Persistence for Idiomatic Java
- *
- * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as
- * indicated by the @author tags or express copyright attribution
- * statements applied by the authors. All third-party contributions are
- * distributed under license by Red Hat Middleware LLC.
- *
- * This copyrighted material is made available to anyone wishing to use, modify,
- * copy, or redistribute it subject to the terms and conditions of the GNU
- * Lesser General Public License, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this distribution; if not, write to:
- * Free Software Foundation, Inc.
- * 51 Franklin Street, Fifth Floor
- * Boston, MA 02110-1301 USA
- *
- */
-package org.hibernate.dialect;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Properties;
-
-import org.hibernate.HibernateException;
-import org.hibernate.cfg.Environment;
-import org.hibernate.util.ReflectHelper;
-
-/**
- * A factory for generating Dialect instances.
- *
- * @author Steve Ebersole
- */
-public class DialectFactory {
-
-  /**
-   * Builds an appropriate Dialect instance.
-   * <p/>
-   * If a dialect is explicitly named in the incoming properties, it is used. Otherwise, the database name and version
-   * (obtained from connection metadata) are used to make the dertemination.
-   * <p/>
-   * An exception is thrown if a dialect was not explicitly set and the database name is not known.
-   *
-   * @param props The configuration properties.
-   * @param databaseName The name of the database product (obtained from metadata).
-   * @param databaseMajorVersion The major version of the database product (obtained from metadata).
-   *
-   * @return The appropriate dialect.
-   *
-   * @throws HibernateException No dialect specified and database name not known.
-   */
-  public static Dialect buildDialect(Properties props, String databaseName, int databaseMajorVersion)
-       throws HibernateException {
-    String dialectName = props.getProperty( Environment.DIALECT );
-    if ( dialectName == null ) {
-      return determineDialect( databaseName, databaseMajorVersion );
-    }
-    else {
-      return buildDialect( dialectName );
-    }
-  }
-
-  /**
-   * Determine the appropriate Dialect to use given the database product name
-   * and major version.
-   *
-   * @param databaseName The name of the database product (obtained from metadata).
-   * @param databaseMajorVersion The major version of the database product (obtained from metadata).
-   *
-   * @return An appropriate dialect instance.
-   */
-  public static Dialect determineDialect(String databaseName, int databaseMajorVersion) {
-    if ( databaseName == null ) {
-      throw new HibernateException( "Hibernate Dialect must be explicitly set" );
-    }
-
-    DatabaseDialectMapper mapper = ( DatabaseDialectMapper ) MAPPERS.get( databaseName );
-    if ( mapper == null ) {
-      throw new HibernateException( "Hibernate Dialect must be explicitly set for database: " + databaseName );
-    }
-
-    String dialectName = mapper.getDialectClass( databaseMajorVersion );
-    return buildDialect( dialectName );
-  }
-
-  /**
-   * Returns a dialect instance given the name of the class to use.
-   *
-   * @param dialectName The name of the dialect class.
-   *
-   * @return The dialect instance.
-   */
-  public static Dialect buildDialect(String dialectName) {
-    try {
-      return ( Dialect ) ReflectHelper.classForName( dialectName ).newInstance();
-    }
-    catch ( ClassNotFoundException cnfe ) {
-      throw new HibernateException( "Dialect class not found: " + dialectName );
-    }
-    catch ( Exception e ) {
-      throw new HibernateException( "Could not instantiate dialect class", e );
-    }
-  }
-
-  /**
-   * For a given database product name, instances of
-   * DatabaseDialectMapper know which Dialect to use for different versions.
-   */
-  public static interface DatabaseDialectMapper {
-    public String getDialectClass(int majorVersion);
-  }
-
-  /**
-   * A simple DatabaseDialectMapper for dialects which are independent
-   * of the underlying database product version.
-   */
-  public static class VersionInsensitiveMapper implements DatabaseDialectMapper {
-    private String dialectClassName;
-
-    public VersionInsensitiveMapper(String dialectClassName) {
-      this.dialectClassName = dialectClassName;
-    }
-
-    public String getDialectClass(int majorVersion) {
-      return dialectClassName;
-    }
-  }
-
-  // TODO : this is the stuff it'd be nice to move to a properties file or some other easily user-editable place
-  private static final Map MAPPERS = new HashMap();
-  static {
-    // detectors...
-    MAPPERS.put( "HSQL Database Engine", new VersionInsensitiveMapper( "org.hibernate.dialect.HSQLDialect" ) );
-    MAPPERS.put( "H2", new VersionInsensitiveMapper( "org.hibernate.dialect.H2Dialect" ) );
-    MAPPERS.put( "MySQL", new VersionInsensitiveMapper( "org.hibernate.dialect.MySQLDialect" ) );
-    MAPPERS.put( "PostgreSQL", new VersionInsensitiveMapper( "org.hibernate.dialect.PostgreSQLDialect" ) );
-    MAPPERS.put( "Apache Derby", new VersionInsensitiveMapper( "org.hibernate.dialect.DerbyDialect" ) );
-
-    MAPPERS.put( "Ingres", new VersionInsensitiveMapper( "org.hibernate.dialect.IngresDialect" ) );
-    MAPPERS.put( "ingres", new VersionInsensitiveMapper( "org.hibernate.dialect.IngresDialect" ) );
-    MAPPERS.put( "INGRES", new VersionInsensitiveMapper( "org.hibernate.dialect.IngresDialect" ) );
-
-    MAPPERS.put( "Microsoft SQL Server Database", new VersionInsensitiveMapper( "org.hibernate.dialect.SQLServerDialect" ) );
-    MAPPERS.put( "Microsoft SQL Server", new VersionInsensitiveMapper( "org.hibernate.dialect.SQLServerDialect" ) );
-    MAPPERS.put( "Sybase SQL Server", new VersionInsensitiveMapper( "org.hibernate.dialect.SybaseDialect" ) );
-    MAPPERS.put( "Adaptive Server Enterprise", new VersionInsensitiveMapper( "org.hibernate.dialect.SybaseDialect" ) );
-
-    MAPPERS.put( "Informix Dynamic Server", new VersionInsensitiveMapper( "org.hibernate.dialect.InformixDialect" ) );
-
-    // thanks goodness for "universal" databases...
-    MAPPERS.put( "DB2/NT", new VersionInsensitiveMapper( "org.hibernate.dialect.DB2Dialect" ) );
-    MAPPERS.put( "DB2/LINUX", new VersionInsensitiveMapper( "org.hibernate.dialect.DB2Dialect" ) );
-    MAPPERS.put( "DB2/6000", new VersionInsensitiveMapper( "org.hibernate.dialect.DB2Dialect" ) );
-    MAPPERS.put( "DB2/HPUX", new VersionInsensitiveMapper( "org.hibernate.dialect.DB2Dialect" ) );
-    MAPPERS.put( "DB2/SUN", new VersionInsensitiveMapper( "org.hibernate.dialect.DB2Dialect" ) );
-    MAPPERS.put( "DB2/LINUX390", new VersionInsensitiveMapper( "org.hibernate.dialect.DB2Dialect" ) );
-    MAPPERS.put( "DB2/AIX64", new VersionInsensitiveMapper( "org.hibernate.dialect.DB2Dialect" ) );
-
-    MAPPERS.put(
-         "Oracle",
-         new DatabaseDialectMapper() {
-           public String getDialectClass(int majorVersion) {
-            switch ( majorVersion ) {
-              case 8: return Oracle8iDialect.class.getName();
-              case 9: return Oracle9iDialect.class.getName();
-              case 10: return Oracle10gDialect.class.getName();
-              default: throw new HibernateException( "unknown Oracle major version [" + majorVersion + "]" );
-            }
-           }
-         }
-    );
-  }
-}

Added: core/trunk/core/src/main/java/org/hibernate/dialect/resolver/AbstractDialectResolver.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/dialect/resolver/AbstractDialectResolver.java                  (rev 0)
+++ core/trunk/core/src/main/java/org/hibernate/dialect/resolver/AbstractDialectResolver.java  2008-10-13 15:29:23 UTC (rev 15343)
@@(protected) @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as
+ * indicated by the @author tags or express copyright attribution
+ * statements applied by the authors. All third-party contributions are
+ * distributed under license by Red Hat Middleware LLC.
+ *
+ * This copyrighted material is made available to anyone wishing to use, modify,
+ * copy, or redistribute it subject to the terms and conditions of the GNU
+ * Lesser General Public License, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this distribution; if not, write to:
+ * Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor
+ * Boston, MA 02110-1301 USA
+ *
+ */
+package org.hibernate.dialect.resolver;
+
+import java.sql.DatabaseMetaData;
+import java.sql.SQLException;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.hibernate.dialect.Dialect;
+import org.hibernate.exception.JDBCConnectionException;
+import org.hibernate.JDBCException;
+
+/**
+ * A templated resolver impl which delegates to the {@(protected)
+ * and handles any thrown {@(protected).
+ *
+ * @author Steve Ebersole
+ */
+public abstract class AbstractDialectResolver implements DialectResolver {
+  private static final Logger log = LoggerFactory.getLogger( AbstractDialectResolver.class );
+
+  /**
+   * {@(protected)}
+   * <p/>
+   * Here we template the resolution, delegating to {@(protected)
+   * {@(protected).
+   */
+  public final Dialect resolveDialect(DatabaseMetaData metaData) {
+    try {
+      return resolveDialectInternal( metaData );
+    }
+    catch ( SQLException sqlException ) {
+      JDBCException jdbcException = BasicSQLExceptionConverter.INSTANCE.convert( sqlException );
+      if ( jdbcException instanceof JDBCConnectionException ) {
+        throw jdbcException;
+      }
+      else {
+        log.warn( BasicSQLExceptionConverter.MSG + " : " + sqlException.getMessage() );
+        return null;
+      }
+    }
+    catch ( Throwable t ) {
+      log.warn( "Error executing resolver [" + this + "] : " + t.getMessage() );
+      return null;
+    }
+  }
+
+  /**
+   * Perform the actual resolution without caring about handling {@(protected).
+   *
+   * @param metaData The database metadata
+   * @return The resolved dialect, or null if we could not resolve.
+   * @throws SQLException Indicates problems accessing the metadata.
+   */
+  protected abstract Dialect resolveDialectInternal(DatabaseMetaData metaData) throws SQLException;
+}

Added: core/trunk/core/src/main/java/org/hibernate/dialect/resolver/BasicDialectResolver.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/dialect/resolver/BasicDialectResolver.java                  (rev 0)
+++ core/trunk/core/src/main/java/org/hibernate/dialect/resolver/BasicDialectResolver.java  2008-10-13 15:29:23 UTC (rev 15343)
@@(protected) @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as
+ * indicated by the @author tags or express copyright attribution
+ * statements applied by the authors. All third-party contributions are
+ * distributed under license by Red Hat Middleware LLC.
+ *
+ * This copyrighted material is made available to anyone wishing to use, modify,
+ * copy, or redistribute it subject to the terms and conditions of the GNU
+ * Lesser General Public License, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this distribution; if not, write to:
+ * Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor
+ * Boston, MA 02110-1301 USA
+ *
+ */
+package org.hibernate.dialect.resolver;
+
+import java.sql.DatabaseMetaData;
+import java.sql.SQLException;
+
+import org.hibernate.dialect.Dialect;
+import org.hibernate.HibernateException;
+
+/**
+ * Intended as support for custom resolvers.
+ *
+ * @author Steve Ebersole
+ */
+public class BasicDialectResolver extends AbstractDialectResolver {
+  public static final int VERSION_INSENSITIVE_VERSION = -9999;
+
+  private final String matchingName;
+  private final int matchingVersion;
+  private final Class dialectClass;
+
+  public BasicDialectResolver(String matchingName, Class dialectClass) {
+    this( matchingName, VERSION_INSENSITIVE_VERSION, dialectClass );
+  }
+
+  public BasicDialectResolver(String matchingName, int matchingVersion, Class dialectClass) {
+    this.matchingName = matchingName;
+    this.matchingVersion = matchingVersion;
+    this.dialectClass = dialectClass;
+  }
+
+  protected final Dialect resolveDialectInternal(DatabaseMetaData metaData) throws SQLException {
+    final String databaseName = metaData.getDatabaseProductName();
+    final int databaseMajorVersion = metaData.getDatabaseMajorVersion();
+
+    if ( matchingName.equalsIgnoreCase( databaseName )
+        && ( matchingVersion == VERSION_INSENSITIVE_VERSION || matchingVersion == databaseMajorVersion ) ) {
+      try {
+        return ( Dialect ) dialectClass.newInstance();
+      }
+      catch ( HibernateException e ) {
+        // conceivable that the dialect ctor could throw HibernateExceptions, so don't re-wrap
+        throw e;
+      }
+      catch ( Throwable t ) {
+        throw new HibernateException(
+            "Could not instantiate specified Dialect class [" + dialectClass.getName() + "]",
+            t
+        );
+      }
+    }
+
+    return null;
+  }
+}

Added: core/trunk/core/src/main/java/org/hibernate/dialect/resolver/BasicSQLExceptionConverter.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/dialect/resolver/BasicSQLExceptionConverter.java                  (rev 0)
+++ core/trunk/core/src/main/java/org/hibernate/dialect/resolver/BasicSQLExceptionConverter.java  2008-10-13 15:29:23 UTC (rev 15343)
@@(protected) @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as
+ * indicated by the @author tags or express copyright attribution
+ * statements applied by the authors. All third-party contributions are
+ * distributed under license by Red Hat Middleware LLC.
+ *
+ * This copyrighted material is made available to anyone wishing to use, modify,
+ * copy, or redistribute it subject to the terms and conditions of the GNU
+ * Lesser General Public License, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this distribution; if not, write to:
+ * Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor
+ * Boston, MA 02110-1301 USA
+ *
+ */
+package org.hibernate.dialect.resolver;
+
+import java.sql.SQLException;
+
+import org.hibernate.exception.SQLStateConverter;
+import org.hibernate.exception.ViolatedConstraintNameExtracter;
+import org.hibernate.JDBCException;
+
+/**
+ * A helper to centralize conversion of {@(protected).
+ *
+ * @author Steve Ebersole
+ */
+public class BasicSQLExceptionConverter {
+  public static final BasicSQLExceptionConverter INSTANCE = new BasicSQLExceptionConverter();
+  public static final String MSG = "Unable to query java.sql.DatabaseMetaData";
+
+  private static final SQLStateConverter CONVERTER = new SQLStateConverter( new ConstraintNameExtracter() );
+
+  /**
+   * Perform a conversion.
+   *
+   * @param sqlException The exception to convert.
+   * @return The converted exception.
+   */
+  public JDBCException convert(SQLException sqlException) {
+    return CONVERTER.convert( sqlException, MSG, null );
+  }
+
+  private static class ConstraintNameExtracter implements ViolatedConstraintNameExtracter {
+    /**
+     * {@(protected)}
+     */
+    public String extractConstraintName(SQLException sqle) {
+      return "???";
+    }
+  }
+}

Added: core/trunk/core/src/main/java/org/hibernate/dialect/resolver/DialectFactory.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/dialect/resolver/DialectFactory.java                  (rev 0)
+++ core/trunk/core/src/main/java/org/hibernate/dialect/resolver/DialectFactory.java  2008-10-13 15:29:23 UTC (rev 15343)
@@(protected) @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as
+ * indicated by the @author tags or express copyright attribution
+ * statements applied by the authors. All third-party contributions are
+ * distributed under license by Red Hat Middleware LLC.
+ *
+ * This copyrighted material is made available to anyone wishing to use, modify,
+ * copy, or redistribute it subject to the terms and conditions of the GNU
+ * Lesser General Public License, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this distribution; if not, write to:
+ * Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor
+ * Boston, MA 02110-1301 USA
+ *
+ */
+package org.hibernate.dialect.resolver;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.sql.DatabaseMetaData;
+import java.util.Properties;
+
+import org.hibernate.HibernateException;
+import org.hibernate.dialect.resolver.DialectResolver;
+import org.hibernate.dialect.resolver.DialectResolverSet;
+import org.hibernate.dialect.resolver.StandardDialectResolver;
+import org.hibernate.dialect.Dialect;
+import org.hibernate.cfg.Environment;
+import org.hibernate.util.ReflectHelper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * A factory for generating Dialect instances.
+ *
+ * @author Steve Ebersole
+ * @author Tomoto Shimizu Washio
+ */
+public class DialectFactory {
+  private static final Logger log = LoggerFactory.getLogger( DialectFactory.class );
+
+  private static DialectResolverSet DIALECT_RESOLVERS = new DialectResolverSet();
+
+  static {
+    // register the standard dialect resolver
+    DIALECT_RESOLVERS.addResolver( new StandardDialectResolver() );
+
+    // register resolvers set via Environment property
+    String userSpecifedResolverSetting = Environment.getProperties().getProperty( Environment.DIALECT_RESOLVERS );
+    if ( userSpecifedResolverSetting != null ) {
+      String[] userSpecifedResolvers = userSpecifedResolverSetting.split( "\\s+" );
+      for ( int i = 0; i < userSpecifedResolvers.length; i++ ) {
+        registerDialectResolver( userSpecifedResolvers[i] );
+      }
+    }
+  }
+
+  /*package*/ static void registerDialectResolver(String resolverName) {
+    try {
+      DialectResolver resolver = ( DialectResolver ) ReflectHelper.classForName( resolverName ).newInstance();
+      DIALECT_RESOLVERS.addResolverAtFirst( resolver );
+    }
+    catch ( ClassNotFoundException cnfe ) {
+      log.warn( "Dialect resolver class not found: " + resolverName );
+    }
+    catch ( Exception e ) {
+      log.warn( "Could not instantiate dialect resolver class", e );
+    }
+  }
+
+  /**
+   * Builds an appropriate Dialect instance.
+   * <p/>
+   * If a dialect is explicitly named in the incoming properties, it is used. Otherwise, it is
+   * determined by dialect resolvers based on the passed connection.
+   * <p/>
+   * An exception is thrown if a dialect was not explicitly set and no resolver could make
+   * the determination from the given connection.
+   *
+   * @param properties The configuration properties.
+   * @param connection The configured connection.
+   * @return The appropriate dialect instance.
+   * @throws HibernateException No dialect specified and no resolver could make the determination.
+   */
+  public static Dialect buildDialect(Properties properties, Connection connection) throws HibernateException {
+    String dialectName = properties.getProperty( Environment.DIALECT );
+    if ( dialectName == null ) {
+      return determineDialect( connection );
+    }
+    else {
+      return constructDialect( dialectName );
+    }
+  }
+
+  public static Dialect buildDialect(Properties properties) {
+    String dialectName = properties.getProperty( Environment.DIALECT );
+    if ( dialectName == null ) {
+      throw new HibernateException( "'hibernate.dialect' must be set when no Connection avalable" );
+    }
+    return constructDialect( dialectName );
+  }
+
+  /**
+   * Determine the appropriate Dialect to use given the connection.
+   *
+   * @param connection The configured connection.
+   * @return The appropriate dialect instance.
+   *
+   * @throws HibernateException No connection given or no resolver could make
+   * the determination from the given connection.
+   */
+  private static Dialect determineDialect(Connection connection) {
+    if ( connection == null ) {
+      throw new HibernateException( "Connection cannot be null when 'hibernate.dialect' not set" );
+    }
+
+    try {
+      final DatabaseMetaData databaseMetaData = connection.getMetaData();
+      final Dialect dialect = DIALECT_RESOLVERS.resolveDialect( databaseMetaData );
+
+      if ( dialect == null ) {
+        throw new HibernateException(
+            "Unable to determine Dialect to use [name=" + databaseMetaData.getDatabaseProductName() +
+                ", majorVersion=" + databaseMetaData.getDatabaseMajorVersion() +
+                "]; user must register resolver or explicitly set 'hibernate.dialect'"
+        );
+      }
+
+      return dialect;
+    }
+    catch ( SQLException sqlException ) {
+      throw new HibernateException(
+          "Unable to access java.sql.DatabaseMetaData to determine appropriate Dialect to use",
+          sqlException
+      );
+    }
+  }
+
+  /**
+   * Returns a dialect instance given the name of the class to use.
+   *
+   * @param dialectName The name of the dialect class.
+   *
+   * @return The dialect instance.
+   */
+  public static Dialect constructDialect(String dialectName) {
+    try {
+      return ( Dialect ) ReflectHelper.classForName( dialectName ).newInstance();
+    }
+    catch ( ClassNotFoundException cnfe ) {
+      throw new HibernateException( "Dialect class not found: " + dialectName, cnfe );
+    }
+    catch ( Exception e ) {
+      throw new HibernateException( "Could not instantiate dialect class", e );
+    }
+  }
+}

Added: core/trunk/core/src/main/java/org/hibernate/dialect/resolver/DialectResolver.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/dialect/resolver/DialectResolver.java                  (rev 0)
+++ core/trunk/core/src/main/java/org/hibernate/dialect/resolver/DialectResolver.java  2008-10-13 15:29:23 UTC (rev 15343)
@@(protected) @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as
+ * indicated by the @author tags or express copyright attribution
+ * statements applied by the authors. All third-party contributions are
+ * distributed under license by Red Hat Middleware LLC.
+ *
+ * This copyrighted material is made available to anyone wishing to use, modify,
+ * copy, or redistribute it subject to the terms and conditions of the GNU
+ * Lesser General Public License, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this distribution; if not, write to:
+ * Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor
+ * Boston, MA 02110-1301 USA
+ *
+ */
+package org.hibernate.dialect.resolver;
+
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+
+import org.hibernate.dialect.Dialect;
+import org.hibernate.exception.JDBCConnectionException;
+
+/**
+ * Contract for determining the {@(protected)}.
+ *
+ * @author Tomoto Shimizu Washio
+ * @author Steve Ebersole
+ */
+public interface DialectResolver {
+  /**
+   * Determine the {@(protected)
+   * expected to return the {@(protected)
+   * the criteria handled by this impl.
+   *
+   * @param metaData The JDBC metadata.
+   * @return The dialect to use, or null.
+   * @throws JDBCConnectionException Indicates a 'non transient connection problem', which indicates that
+   * we should stop resolution attempts.
+   */
+  public Dialect resolveDialect(DatabaseMetaData metaData) throws JDBCConnectionException;
+}

Added: core/trunk/core/src/main/java/org/hibernate/dialect/resolver/DialectResolverSet.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/dialect/resolver/DialectResolverSet.java                  (rev 0)
+++ core/trunk/core/src/main/java/org/hibernate/dialect/resolver/DialectResolverSet.java  2008-10-13 15:29:23 UTC (rev 15343)
@@(protected) @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as
+ * indicated by the @author tags or express copyright attribution
+ * statements applied by the authors. All third-party contributions are
+ * distributed under license by Red Hat Middleware LLC.
+ *
+ * This copyrighted material is made available to anyone wishing to use, modify,
+ * copy, or redistribute it subject to the terms and conditions of the GNU
+ * Lesser General Public License, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this distribution; if not, write to:
+ * Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor
+ * Boston, MA 02110-1301 USA
+ *
+ */
+package org.hibernate.dialect.resolver;
+
+import java.sql.DatabaseMetaData;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.hibernate.dialect.Dialect;
+import org.hibernate.exception.JDBCConnectionException;
+
+/**
+ * A {@(protected)
+ * registered sub-resolvers. Sub-resolvers may be registered by calling either {@(protected)
+ * {@(protected)}.
+ *
+ * @author Tomoto Shimizu Washio
+ */
+public class DialectResolverSet implements DialectResolver {
+  private static Logger log = LoggerFactory.getLogger( DialectResolverSet.class );
+
+  private List resolvers = new ArrayList();
+
+  /**
+   * {@(protected)}
+   */
+  public Dialect resolveDialect(DatabaseMetaData metaData) {
+    Iterator i = resolvers.iterator();
+    while ( i.hasNext() ) {
+      final DialectResolver resolver = ( DialectResolver ) i.next();
+      try {
+        Dialect dialect = resolver.resolveDialect( metaData );
+        if ( dialect != null ) {
+          return dialect;
+        }
+      }
+      catch ( JDBCConnectionException e ) {
+        throw e;
+      }
+      catch ( Throwable t ) {
+        log.info( "sub-resolver threw unexpected exception, continuing to next : " + t.getMessage() );
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Add a resolver at the end of the underlying resolver list. The resolver added by this method is at lower
+   * priority than any other existing resolvers.
+   *
+   * @param resolver The resolver to add.
+   */
+  public void addResolver(DialectResolver resolver) {
+    resolvers.add( resolver );
+  }
+
+  /**
+   * Add a resolver at the beginning of the underlying resolver list. The resolver added by this method is at higher
+   * priority than any other existing resolvers.
+   *
+   * @param resolver The resolver to add.
+   */
+  public void addResolverAtFirst(DialectResolver resolver) {
+    resolvers.add( 0, resolver );
+  }
+}

Added: core/trunk/core/src/main/java/org/hibernate/dialect/resolver/StandardDialectResolver.java
===================================================================
--- core/trunk/core/src/main/java/org/hibernate/dialect/resolver/StandardDialectResolver.java                  (rev 0)
+++ core/trunk/core/src/main/java/org/hibernate/dialect/resolver/StandardDialectResolver.java  2008-10-13 15:29:23 UTC (rev 15343)
@@(protected) @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as
+ * indicated by the @author tags or express copyright attribution
+ * statements applied by the authors. All third-party contributions are
+ * distributed under license by Red Hat Middleware LLC.
+ *
+ * This copyrighted material is made available to anyone wishing to use, modify,
+ * copy, or redistribute it subject to the terms and conditions of the GNU
+ * Lesser General Public License, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this distribution; if not, write to:
+ * Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor
+ * Boston, MA 02110-1301 USA
+ *
+ */
+package org.hibernate.dialect.resolver;
+
+import java.sql.DatabaseMetaData;
+import java.sql.SQLException;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.hibernate.dialect.Dialect;
+import org.hibernate.dialect.HSQLDialect;
+import org.hibernate.dialect.H2Dialect;
+import org.hibernate.dialect.MySQLDialect;
+import org.hibernate.dialect.PostgreSQLDialect;
+import org.hibernate.dialect.DerbyDialect;
+import org.hibernate.dialect.IngresDialect;
+import org.hibernate.dialect.SQLServerDialect;
+import org.hibernate.dialect.SybaseDialect;
+import org.hibernate.dialect.InformixDialect;
+import org.hibernate.dialect.DB2Dialect;
+import org.hibernate.dialect.Oracle10gDialect;
+import org.hibernate.dialect.Oracle9iDialect;
+import org.hibernate.dialect.Oracle8iDialect;
+
+/**
+ * The standard Hibernate resolver.
+ *
+ * @author Steve Ebersole
+ */
+public class StandardDialectResolver extends AbstractDialectResolver{
+  private static final Logger log = LoggerFactory.getLogger( StandardDialectResolver.class );
+
+  protected Dialect resolveDialectInternal(DatabaseMetaData metaData) throws SQLException {
+    String databaseName = metaData.getDatabaseProductName();
+    int databaseMajorVersion = metaData.getDatabaseMajorVersion();
+
+    if ( "HSQL Database Engine".equals( databaseName ) ) {
+      return new HSQLDialect();
+    }
+
+    if ( "H2".equals( databaseName ) ) {
+      return new H2Dialect();
+    }
+
+    if ( "MySQL".equals( databaseName ) ) {
+      return new MySQLDialect();
+    }
+
+    if ( "PostgreSQL".equals( databaseName ) ) {
+      return new PostgreSQLDialect();
+    }
+
+    if ( "Apache Derby".equals( databaseName ) ) {
+      return new DerbyDialect();
+    }
+
+    if ( "ingres".equalsIgnoreCase( databaseName ) ) {
+      return new IngresDialect();
+    }
+
+    if ( databaseName.startsWith( "Microsoft SQL Server" ) ) {
+      return new SQLServerDialect();
+    }
+
+    if ( "Sybase SQL Server".equals( databaseName ) || "Adaptive Server Enterprise".equals( databaseName ) ) {
+      return new SybaseDialect();
+    }
+
+    if ( "Informix Dynamic Server".equals( databaseName ) ) {
+      return new InformixDialect();
+    }
+
+    if ( databaseName.startsWith( "DB2/" ) ) {
+      return new DB2Dialect();
+    }
+
+    if ( "Oracle".equals( databaseName ) ) {
+      switch ( databaseMajorVersion ) {
+        case 11:
+          log.warn( "Oracle 11g is not yet fully supported; using 10g dialect" );
+          return new Oracle10gDialect();
+        case 10:
+          return new Oracle10gDialect();
+        case 9:
+          return new Oracle9iDialect();
+        case 8:
+          return new Oracle8iDialect();
+        default:
+          log.warn( "unknown Oracle major version [" + databaseMajorVersion + "]" );
+      }
+    }
+
+    return null;
+  }
+}

Added: core/trunk/core/src/test/java/org/hibernate/dialect/Mocks.java
===================================================================
--- core/trunk/core/src/test/java/org/hibernate/dialect/Mocks.java                  (rev 0)
+++ core/trunk/core/src/test/java/org/hibernate/dialect/Mocks.java  2008-10-13 15:29:23 UTC (rev 15343)
@@(protected) @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as
+ * indicated by the @author tags or express copyright attribution
+ * statements applied by the authors. All third-party contributions are
+ * distributed under license by Red Hat Middleware LLC.
+ *
+ * This copyrighted material is made available to anyone wishing to use, modify,
+ * copy, or redistribute it subject to the terms and conditions of the GNU
+ * Lesser General Public License, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this distribution; if not, write to:
+ * Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor
+ * Boston, MA 02110-1301 USA
+ *
+ */
+package org.hibernate.dialect;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.sql.SQLException;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+
+/**
+ * TODO : javadoc
+ *
+ * @author Steve Ebersole
+ */
+public class Mocks {
+
+  public static Connection createConnection(String dbName, int version) {
+    DatabaseMetaDataHandler metadataHandler = new DatabaseMetaDataHandler( dbName, version );
+    ConnectionHandler connectionHandler = new ConnectionHandler();
+
+    DatabaseMetaData metadataProxy = ( DatabaseMetaData ) Proxy.newProxyInstance(
+        ClassLoader.getSystemClassLoader(),
+        new Class[] { DatabaseMetaData.class },
+        metadataHandler
+    );
+
+    Connection connectionProxy = ( Connection ) Proxy.newProxyInstance(
+        ClassLoader.getSystemClassLoader(),
+        new Class[] { Connection.class },
+        connectionHandler
+    );
+
+    metadataHandler.setConnectionProxy( connectionProxy );
+    connectionHandler.setMetadataProxy( metadataProxy );
+
+    return connectionProxy;
+  }
+
+  private static class ConnectionHandler implements InvocationHandler {
+    private DatabaseMetaData metadataProxy;
+
+    public void setMetadataProxy(DatabaseMetaData metadataProxy) {
+      this.metadataProxy = metadataProxy;
+    }
+
+    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+      final String methodName = method.getName();
+      if ( "getMetaData".equals( methodName ) ) {
+        return metadataProxy;
+      }
+
+      if ( "toString".equals( methodName ) ) {
+        return "Connection proxy [@(protected)() + "]";
+      }
+
+      if ( "hashCode".equals( methodName ) ) {
+        return new Integer( this.hashCode() );
+      }
+
+      if ( canThrowSQLException( method ) ) {
+        throw new SQLException();
+      }
+      else {
+        throw new UnsupportedOperationException();
+      }
+    }
+  }
+
+  private static class DatabaseMetaDataHandler implements InvocationHandler {
+    private final String databaseName;
+    private final int majorVersion;
+
+    private Connection connectionProxy;
+
+    public void setConnectionProxy(Connection connectionProxy) {
+      this.connectionProxy = connectionProxy;
+    }
+
+    private DatabaseMetaDataHandler(String databaseName, int majorVersion) {
+      this.databaseName = databaseName;
+      this.majorVersion = majorVersion;
+    }
+
+    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+      final String methodName = method.getName();
+      if ( "getDatabaseProductName".equals( methodName ) ) {
+        return databaseName;
+      }
+
+      if ( "getDatabaseMajorVersion".equals( methodName ) ) {
+        return new Integer( majorVersion );
+      }
+
+      if ( "getConnection".equals( methodName ) ) {
+        return connectionProxy;
+      }
+
+      if ( "toString".equals( methodName ) ) {
+        return "DatabaseMetaData proxy [db-name=" + databaseName + ", version=" + majorVersion + "]";
+      }
+
+      if ( "hashCode".equals( methodName ) ) {
+        return new Integer( this.hashCode() );
+      }
+
+      if ( canThrowSQLException( method ) ) {
+        throw new SQLException();
+      }
+      else {
+        throw new UnsupportedOperationException();
+      }
+    }
+  }
+
+  private static boolean canThrowSQLException(Method method) {
+    final Class[] exceptions = method.getExceptionTypes();
+    for ( int i = 0; i < exceptions.length; i++ ) {
+      if ( SQLException.class.isAssignableFrom( exceptions[i] ) ) {
+        return true;
+      }
+    }
+    return false;
+  }
+}

Added: core/trunk/core/src/test/java/org/hibernate/dialect/TestingDialects.java
===================================================================
--- core/trunk/core/src/test/java/org/hibernate/dialect/TestingDialects.java                  (rev 0)
+++ core/trunk/core/src/test/java/org/hibernate/dialect/TestingDialects.java  2008-10-13 15:29:23 UTC (rev 15343)
@@(protected) @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as
+ * indicated by the @author tags or express copyright attribution
+ * statements applied by the authors. All third-party contributions are
+ * distributed under license by Red Hat Middleware LLC.
+ *
+ * This copyrighted material is made available to anyone wishing to use, modify,
+ * copy, or redistribute it subject to the terms and conditions of the GNU
+ * Lesser General Public License, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this distribution; if not, write to:
+ * Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor
+ * Boston, MA 02110-1301 USA
+ *
+ */
+package org.hibernate.dialect;
+
+import java.sql.SQLException;
+import java.sql.DatabaseMetaData;
+
+import org.hibernate.dialect.resolver.AbstractDialectResolver;
+import org.hibernate.dialect.resolver.BasicDialectResolver;
+import org.hibernate.HibernateException;
+
+/**
+ * TODO : javadoc
+ *
+ * @author Steve Ebersole
+ */
+public class TestingDialects {
+
+  public static class MyDialect1 extends Dialect {
+  }
+
+  public static class MyDialect21 extends Dialect {
+  }
+
+  public static class MyDialect22 extends Dialect {
+  }
+
+  public static class MySpecialDB2Dialect extends Dialect {
+  }
+
+  public static class MyDialectResolver1 extends AbstractDialectResolver {
+    protected Dialect resolveDialectInternal(DatabaseMetaData metaData) throws SQLException {
+      String databaseName = metaData.getDatabaseProductName();
+      int databaseMajorVersion = metaData.getDatabaseMajorVersion();
+      if ( "MyDatabase1".equals( databaseName ) ) {
+        return new MyDialect1();
+      }
+      if ( "MyDatabase2".equals( databaseName ) ) {
+        if ( databaseMajorVersion >= 2 ) {
+          return new MyDialect22();
+        }
+        if ( databaseMajorVersion >= 1 ) {
+          return new MyDialect21();
+        }
+      }
+      return null;
+    }
+  }
+
+  public static class MyDialectResolver2 extends BasicDialectResolver {
+    public MyDialectResolver2() {
+      super( "MyTrickyDatabase1", MyDialect1.class );
+    }
+  }
+
+  public static class ErrorDialectResolver1 extends AbstractDialectResolver {
+    public Dialect resolveDialectInternal(DatabaseMetaData metaData) throws SQLException {
+      String databaseName = metaData.getDatabaseProductName();
+      if ( databaseName.equals( "ConnectionErrorDatabase1" ) ) {
+        throw new SQLException( "Simulated connection error", "08001" );
+      }
+      else {
+        throw new SQLException();
+      }
+    }
+  }
+
+  public static class ErrorDialectResolver2 extends AbstractDialectResolver {
+    public Dialect resolveDialectInternal(DatabaseMetaData metaData) throws SQLException {
+      String databaseName = metaData.getDatabaseProductName();
+      if ( databaseName.equals( "ErrorDatabase1" ) ) {
+        throw new SQLException();
+      }
+      if ( databaseName.equals( "ErrorDatabase2" ) ) {
+        throw new HibernateException( "This is a trap!" );
+      }
+      return null;
+    }
+  }
+
+  public static class MyOverridingDialectResolver1 extends BasicDialectResolver {
+    public MyOverridingDialectResolver1() {
+      super( "DB2/MySpecialPlatform", MySpecialDB2Dialect.class );
+    }
+  }
+
+}

Added: core/trunk/core/src/test/java/org/hibernate/dialect/resolver/DialectFactoryTest.java
===================================================================
--- core/trunk/core/src/test/java/org/hibernate/dialect/resolver/DialectFactoryTest.java                  (rev 0)
+++ core/trunk/core/src/test/java/org/hibernate/dialect/resolver/DialectFactoryTest.java  2008-10-13 15:29:23 UTC (rev 15343)
@@(protected) @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as
+ * indicated by the @author tags or express copyright attribution
+ * statements applied by the authors. All third-party contributions are
+ * distributed under license by Red Hat Middleware LLC.
+ *
+ * This copyrighted material is made available to anyone wishing to use, modify,
+ * copy, or redistribute it subject to the terms and conditions of the GNU
+ * Lesser General Public License, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this distribution; if not, write to:
+ * Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor
+ * Boston, MA 02110-1301 USA
+ *
+ */
+package org.hibernate.dialect.resolver;
+
+import java.util.Properties;
+import java.sql.Connection;
+
+import junit.framework.TestSuite;
+import junit.framework.TestCase;
+import junit.framework.Test;
+
+import org.hibernate.HibernateException;
+import org.hibernate.dialect.resolver.DialectFactory;
+import org.hibernate.dialect.HSQLDialect;
+import org.hibernate.dialect.H2Dialect;
+import org.hibernate.dialect.MySQLDialect;
+import org.hibernate.dialect.PostgreSQLDialect;
+import org.hibernate.dialect.DerbyDialect;
+import org.hibernate.dialect.IngresDialect;
+import org.hibernate.dialect.SQLServerDialect;
+import org.hibernate.dialect.SybaseDialect;
+import org.hibernate.dialect.InformixDialect;
+import org.hibernate.dialect.DB2Dialect;
+import org.hibernate.dialect.Oracle8iDialect;
+import org.hibernate.dialect.Oracle9iDialect;
+import org.hibernate.dialect.Oracle10gDialect;
+import org.hibernate.dialect.TestingDialects;
+import org.hibernate.dialect.Mocks;
+import org.hibernate.cfg.Environment;
+
+/**
+ * TODO : javadoc
+ *
+ * @author Steve Ebersole
+ */
+public class DialectFactoryTest extends TestCase {
+  public DialectFactoryTest(String name) {
+    super( name );
+  }
+
+  public static Test suite() {
+    return new TestSuite( DialectFactoryTest.class );
+  }
+
+  public void testBuildDialectByClass() {
+    assertEquals(
+        HSQLDialect.class,
+        DialectFactory.constructDialect( "org.hibernate.dialect.HSQLDialect" ).getClass()
+    );
+
+    try {
+      DialectFactory.constructDialect( "org.hibernate.dialect.NoSuchDialect" );
+      fail();
+    }
+    catch ( HibernateException e ) {
+      assertEquals( "unexpected exception type", e.getCause().getClass(), ClassNotFoundException.class );
+    }
+
+    try {
+      DialectFactory.constructDialect( "java.lang.Object" );
+      fail();
+    }
+    catch ( HibernateException e ) {
+      assertEquals( "unexpected exception type", e.getCause().getClass(), ClassCastException.class );
+    }
+  }
+
+  public void testBuildDialectByProperties() {
+    Properties props = new Properties();
+
+    try {
+      DialectFactory.buildDialect( props, null );
+      fail();
+    }
+    catch ( HibernateException e ) {
+      assertNull( e.getCause() );
+    }
+
+    props.setProperty( Environment.DIALECT, "org.hibernate.dialect.HSQLDialect" );
+    assertTrue( DialectFactory.buildDialect( props, null ) instanceof HSQLDialect );
+  }
+
+  public void testPreregisteredDialects() {
+    testDetermination( "HSQL Database Engine", HSQLDialect.class );
+    testDetermination( "H2", H2Dialect.class );
+    testDetermination( "MySQL", MySQLDialect.class );
+    testDetermination( "PostgreSQL", PostgreSQLDialect.class );
+    testDetermination( "Apache Derby", DerbyDialect.class );
+    testDetermination( "Ingres", IngresDialect.class );
+    testDetermination( "ingres", IngresDialect.class );
+    testDetermination( "INGRES", IngresDialect.class );
+    testDetermination( "Microsoft SQL Server Database", SQLServerDialect.class );
+    testDetermination( "Microsoft SQL Server", SQLServerDialect.class );
+    testDetermination( "Sybase SQL Server", SybaseDialect.class );
+    testDetermination( "Adaptive Server Enterprise", SybaseDialect.class );
+    testDetermination( "Informix Dynamic Server", InformixDialect.class );
+    testDetermination( "DB2/NT", DB2Dialect.class );
+    testDetermination( "DB2/LINUX", DB2Dialect.class );
+    testDetermination( "DB2/6000", DB2Dialect.class );
+    testDetermination( "DB2/HPUX", DB2Dialect.class );
+    testDetermination( "DB2/SUN", DB2Dialect.class );
+    testDetermination( "DB2/LINUX390", DB2Dialect.class );
+    testDetermination( "DB2/AIX64", DB2Dialect.class );
+    testDetermination( "Oracle", 8, Oracle8iDialect.class );
+    testDetermination( "Oracle", 9, Oracle9iDialect.class );
+    testDetermination( "Oracle", 10, Oracle10gDialect.class );
+    testDetermination( "Oracle", 11, Oracle10gDialect.class );
+  }
+
+  public void testCustomDialects() {
+    DialectFactory.registerDialectResolver( TestingDialects.MyDialectResolver1.class.getName() );
+    DialectFactory.registerDialectResolver( TestingDialects.MyDialectResolver2.class.getName() );
+    DialectFactory.registerDialectResolver( TestingDialects.ErrorDialectResolver1.class.getName() );
+    DialectFactory.registerDialectResolver( TestingDialects.ErrorDialectResolver2.class.getName() );
+    DialectFactory.registerDialectResolver( TestingDialects.MyOverridingDialectResolver1.class.getName() );
+    DialectFactory.registerDialectResolver( "org.hibernate.dialect.NoSuchDialectResolver" );
+    DialectFactory.registerDialectResolver( "java.lang.Object" );
+
+
+    testDetermination( "MyDatabase1", TestingDialects.MyDialect1.class );
+    testDetermination( "MyDatabase2", 1, TestingDialects.MyDialect21.class );
+    testDetermination( "MyTrickyDatabase1", TestingDialects.MyDialect1.class );
+
+    // This should be mapped to DB2Dialect by default, but actually it will be
+    // my custom dialect because I have registered MyOverridingDialectResolver1.
+    testDetermination( "DB2/MySpecialPlatform", TestingDialects.MySpecialDB2Dialect.class );
+
+    try {
+      testDetermination( "ErrorDatabase1", Void.TYPE );
+      fail();
+    }
+    catch ( HibernateException e ) {
+//      log.info( "Expected SQL error in resolveDialect and ignored", e );
+    }
+
+    try {
+      testDetermination( "ErrorDatabase2", Void.TYPE );
+      fail();
+    }
+    catch ( HibernateException e ) {
+//      log.info( "Expected runtime error in resolveDialect", e );
+    }
+  }
+
+  public void testDialectNotFound() {
+    Properties properties = new Properties();
+    try {
+      DialectFactory.buildDialect( properties, Mocks.createConnection( "NoSuchDatabase", 666 ) );
+      fail();
+    }
+    catch ( HibernateException e ) {
+      assertNull( e.getCause() );
+    }
+  }
+
+  private void testDetermination(String databaseName, Class clazz) {
+    testDetermination( databaseName, -9999, clazz );
+  }
+
+  private void testDetermination(String databaseName, int databaseMajorVersion, Class clazz) {
+    Properties properties = new Properties();
+    Connection conn = Mocks.createConnection( databaseName, databaseMajorVersion );
+    assertEquals( clazz, DialectFactory.buildDialect( properties, conn ).getClass() );
+  }
+}

Added: core/trunk/core/src/test/java/org/hibernate/dialect/resolver/DialectResolverTest.java
===================================================================
--- core/trunk/core/src/test/java/org/hibernate/dialect/resolver/DialectResolverTest.java                  (rev 0)
+++ core/trunk/core/src/test/java/org/hibernate/dialect/resolver/DialectResolverTest.java  2008-10-13 15:29:23 UTC (rev 15343)
@@(protected) @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as
+ * indicated by the @author tags or express copyright attribution
+ * statements applied by the authors. All third-party contributions are
+ * distributed under license by Red Hat Middleware LLC.
+ *
+ * This copyrighted material is made available to anyone wishing to use, modify,
+ * copy, or redistribute it subject to the terms and conditions of the GNU
+ * Lesser General Public License, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this distribution; if not, write to:
+ * Free Software Foundation, Inc.
+ * 51 Franklin Street, Fifth Floor
+ * Boston, MA 02110-1301 USA
+ *
+ */
+package org.hibernate.dialect.resolver;
+
+import java.sql.SQLException;
+
+import junit.framework.TestSuite;
+import junit.framework.Test;
+import junit.framework.TestCase;
+
+import org.hibernate.dialect.Dialect;
+import org.hibernate.dialect.TestingDialects;
+import org.hibernate.dialect.Mocks;
+import org.hibernate.exception.JDBCConnectionException;
+
+/**
+ * TODO : javadoc
+ *
+ * @author Steve Ebersole
+ */
+public class DialectResolverTest extends TestCase {
+
+  public DialectResolverTest(String name) {
+    super( name );
+  }
+
+  public void testDialects() throws Exception {
+    DialectResolverSet resolvers = new DialectResolverSet();
+
+    resolvers.addResolverAtFirst( new TestingDialects.MyDialectResolver1() );
+    resolvers.addResolverAtFirst( new TestingDialects.MyDialectResolver2() );
+
+    testDetermination( resolvers, "MyDatabase1", 1, TestingDialects.MyDialect1.class );
+    testDetermination( resolvers, "MyDatabase1", 2, TestingDialects.MyDialect1.class );
+    testDetermination( resolvers, "MyDatabase2", 0, null );
+    testDetermination( resolvers, "MyDatabase2", 1, TestingDialects.MyDialect21.class );
+    testDetermination( resolvers, "MyDatabase2", 2, TestingDialects.MyDialect22.class );
+    testDetermination( resolvers, "MyDatabase2", 3, TestingDialects.MyDialect22.class );
+    testDetermination( resolvers, "MyDatabase3", 1, null );
+    testDetermination( resolvers, "MyTrickyDatabase1", 1, TestingDialects.MyDialect1.class );
+  }
+
+  public void testErrorAndOrder() throws Exception {
+    DialectResolverSet resolvers = new DialectResolverSet();
+    resolvers.addResolverAtFirst( new TestingDialects.MyDialectResolver1() );
+    resolvers.addResolver( new TestingDialects.ErrorDialectResolver1() );
+    resolvers.addResolverAtFirst( new TestingDialects.ErrorDialectResolver1() );
+    resolvers.addResolver( new TestingDialects.MyDialectResolver2() );
+
+    // Non-connection errors are suppressed.
+    testDetermination( resolvers, "MyDatabase1", 1, TestingDialects.MyDialect1.class );
+    testDetermination( resolvers, "MyTrickyDatabase1", 1, TestingDialects.MyDialect1.class );
+    testDetermination( resolvers, "NoSuchDatabase", 1, null );
+
+    // Connection errors are reported
+    try {
+      testDetermination( resolvers, "ConnectionErrorDatabase1", 1, null );
+      fail();
+    }
+    catch ( JDBCConnectionException e ) {
+      // expected
+    }
+  }
+
+  public void testBasicDialectResolver() throws Exception {
+    DialectResolverSet resolvers = new DialectResolverSet();
+    // Simulating MyDialectResolver1 by BasicDialectResolvers
+    resolvers.addResolver( new BasicDialectResolver( "MyDatabase1", TestingDialects.MyDialect1.class ) );
+    resolvers.addResolver( new BasicDialectResolver( "MyDatabase2", 1, TestingDialects.MyDialect21.class ) );
+    resolvers.addResolver( new BasicDialectResolver( "MyDatabase2", 2, TestingDialects.MyDialect22.class ) );
+    resolvers.addResolver( new BasicDialectResolver( "ErrorDatabase1", Object.class ) );
+    testDetermination( resolvers, "MyDatabase1", 1, TestingDialects.MyDialect1.class );
+
+    testDetermination( resolvers, "MyDatabase1", 2, TestingDialects.MyDialect1.class );
+    testDetermination( resolvers, "MyDatabase2", 0, null );
+    testDetermination( resolvers, "MyDatabase2", 1, TestingDialects.MyDialect21.class );
+    testDetermination( resolvers, "MyDatabase2", 2, TestingDialects.MyDialect22.class );
+    testDetermination( resolvers, "ErrorDatabase1", 0, null );
+  }
+
+
+  private void testDetermination(
+      DialectResolver resolver,
+      String databaseName,
+      int version,
+      Class dialectClass) throws SQLException {
+    Dialect dialect = resolver.resolveDialect( Mocks.createConnection( databaseName, version ).getMetaData() );
+    if ( dialectClass == null ) {
+      assertEquals( null, dialect );
+    }
+    else {
+      assertEquals( dialectClass, dialect.getClass() );
+    }
+  }
+
+  public static Test suite() {
+    return new TestSuite( DialectResolverTest.class );
+  }
+}

Added: core/trunk/core/src/test/resources/log4j.properties
===================================================================
--- core/trunk/core/src/test/resources/log4j.properties                  (rev 0)
+++ core/trunk/core/src/test/resources/log4j.properties  2008-10-13 15:29:23 UTC (rev 15343)
@@(protected) @@
+#
+# Hibernate, Relational Persistence for Idiomatic Java
+#
+# Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as
+# indicated by the @author tags or express copyright attribution
+# statements applied by the authors. All third-party contributions are
+# distributed under license by Red Hat Middleware LLC.
+#
+# This copyrighted material is made available to anyone wishing to use, modify,
+# copy, or redistribute it subject to the terms and conditions of the GNU
+# Lesser General Public License, as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
+# for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this distribution; if not, write to:
+# Free Software Foundation, Inc.
+# 51 Franklin Street, Fifth Floor
+# Boston, MA 02110-1301 USA
+#
+#
+log4j.appender.stdout=org.apache.log4j.ConsoleAppender
+log4j.appender.stdout.Target=System.out
+log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
+log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
+
+log4j.rootLogger=info, stdout
+
+log4j.logger.org.hibernate.test=info
+log4j.logger.org.hibernate.tool.hbm2ddl=debug

_______________________________________________
hibernate-commits mailing list
hibernate-commits@(protected)
https://lists.jboss.org/mailman/listinfo/hibernate-commits