Package org.hibernate.dialect

Examples of org.hibernate.dialect.Dialect


      return getCurrentTimestamp( session );
    }
  }

  private Date getCurrentTimestamp(SessionImplementor session) {
    Dialect dialect = session.getFactory().getDialect();
    String timestampSelectString = dialect.getCurrentTimestampSelectString();
        if (dialect.isCurrentTimestampSelectStringCallable()) return useCallableStatement(timestampSelectString, session);
        return usePreparedStatement(timestampSelectString, session);
  }
View Full Code Here


  @Override
  public void configure(Map configValues) {
    final JdbcConnectionAccess jdbcConnectionAccess = buildJdbcConnectionAccess( configValues );
    final DialectFactory dialectFactory = serviceRegistry.getService( DialectFactory.class );

    Dialect dialect = null;
    LobCreatorBuilder lobCreatorBuilder = null;

    boolean metaSupportsScrollable = false;
    boolean metaSupportsGetGeneratedKeys = false;
    boolean metaSupportsBatchUpdates = false;
    boolean metaReportsDDLCausesTxnCommit = false;
    boolean metaReportsDDLInTxnSupported = true;
    String extraKeywordsString = "";
    int sqlStateType = -1;
    boolean lobLocatorUpdateCopy = false;
    String catalogName = null;
    String schemaName = null;
    LinkedHashSet<TypeInfo> typeInfoSet = new LinkedHashSet<TypeInfo>();

    // 'hibernate.temp.use_jdbc_metadata_defaults' is a temporary magic value.
    // The need for it is intended to be alleviated with future development, 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).
    boolean useJdbcMetadata = ConfigurationHelper.getBoolean( "hibernate.temp.use_jdbc_metadata_defaults", configValues, true );
    if ( useJdbcMetadata ) {
      try {
        Connection connection = jdbcConnectionAccess.obtainConnection();
        try {
          DatabaseMetaData meta = connection.getMetaData();
          if(LOG.isDebugEnabled()) {
            LOG.debugf( "Database ->\n" + "       name : %s\n" + "    version : %s\n" + "      major : %s\n" + "      minor : %s",
                  meta.getDatabaseProductName(),
                  meta.getDatabaseProductVersion(),
                  meta.getDatabaseMajorVersion(),
                  meta.getDatabaseMinorVersion()
            );
            LOG.debugf( "Driver ->\n" + "       name : %s\n" + "    version : %s\n" + "      major : %s\n" + "      minor : %s",
                  meta.getDriverName(),
                  meta.getDriverVersion(),
                  meta.getDriverMajorVersion(),
                  meta.getDriverMinorVersion()
            );
            LOG.debugf( "JDBC version : %s.%s", meta.getJDBCMajorVersion(), meta.getJDBCMinorVersion() );
          }

          metaSupportsScrollable = meta.supportsResultSetType( ResultSet.TYPE_SCROLL_INSENSITIVE );
          metaSupportsBatchUpdates = meta.supportsBatchUpdates();
          metaReportsDDLCausesTxnCommit = meta.dataDefinitionCausesTransactionCommit();
          metaReportsDDLInTxnSupported = !meta.dataDefinitionIgnoredInTransactions();
          metaSupportsGetGeneratedKeys = meta.supportsGetGeneratedKeys();
          extraKeywordsString = meta.getSQLKeywords();
          sqlStateType = meta.getSQLStateType();
          lobLocatorUpdateCopy = meta.locatorsUpdateCopy();
          typeInfoSet.addAll( TypeInfoExtracter.extractTypeInfo( meta ) );

          dialect = dialectFactory.buildDialect( configValues, connection );

          catalogName = connection.getCatalog();
          SchemaNameResolver schemaNameResolver = determineExplicitSchemaNameResolver( configValues );
          if ( schemaNameResolver == null ) {
// todo : add dialect method
//            schemaNameResolver = dialect.getSchemaNameResolver();
          }
          if ( schemaNameResolver != null ) {
            schemaName = schemaNameResolver.resolveSchemaName( connection );
          }
          lobCreatorBuilder = new LobCreatorBuilder( configValues, connection );
        }
        catch ( SQLException sqle ) {
          LOG.unableToObtainConnectionMetadata( sqle.getMessage() );
        }
        finally {
          if ( connection != null ) {
            jdbcConnectionAccess.releaseConnection( connection );
          }
        }
      }
      catch ( SQLException sqle ) {
        LOG.unableToObtainConnectionToQueryMetadata( sqle.getMessage() );
        dialect = dialectFactory.buildDialect( configValues, null );
      }
      catch ( UnsupportedOperationException uoe ) {
        // user supplied JDBC connections
        dialect = dialectFactory.buildDialect( configValues, null );
      }
    }
    else {
      dialect = dialectFactory.buildDialect( configValues, null );
    }

    final boolean showSQL = ConfigurationHelper.getBoolean( Environment.SHOW_SQL, configValues, false );
    final boolean formatSQL = ConfigurationHelper.getBoolean( Environment.FORMAT_SQL, configValues, false );

    this.dialect = dialect;
    this.lobCreatorBuilder = (
        lobCreatorBuilder == null ?
            new LobCreatorBuilder( configValues, null ) :
            lobCreatorBuilder
    );

    this.sqlStatementLogger =  new SqlStatementLogger( showSQL, formatSQL );
    this.sqlExceptionHelper = new SqlExceptionHelper( dialect.buildSQLExceptionConverter() );
    this.extractedMetaDataSupport = new ExtractedDatabaseMetaDataImpl(
        metaSupportsScrollable,
        metaSupportsGetGeneratedKeys,
        metaSupportsBatchUpdates,
        metaReportsDDLInTxnSupported,
View Full Code Here

          final boolean scroll,
          final SessionImplementor session) throws SQLException, HibernateException {

    queryParameters.processFilters( getSQLString(), session );
    String sql = queryParameters.getFilteredSQL();
    final Dialect dialect = getFactory().getDialect();
    final RowSelection selection = queryParameters.getRowSelection();
    boolean useLimit = useLimit( selection, dialect );
    boolean hasFirstRow = getFirstRow( selection ) > 0;
    boolean useLimitOffset = hasFirstRow && useLimit && dialect.supportsLimitOffset();
    boolean callable = queryParameters.isCallable();

    final boolean canScroll = getFactory().getSettings().isScrollableResultSetsEnabled();
    final boolean useScrollableResultSetToSkip = hasFirstRow &&
        !useLimitOffset && canScroll;
    final ScrollMode scrollMode = getScrollMode( scroll, hasFirstRow, useLimit, queryParameters );
//
//    if(canScroll && ( scroll || useScrollableResultSetToSkip )){
//       scrollMode = scroll ? queryParameters.getScrollMode() : ScrollMode.SCROLL_INSENSITIVE;
//    }else{
//      scrollMode = null;
//    }
    if ( useLimit ) {
      sql = dialect.getLimitString(
          sql.trim(), //use of trim() here is ugly?
          useLimitOffset ? getFirstRow(selection) : 0,
          getMaxOrLimit(selection, dialect)
        );
    }

    sql = preprocessSQL( sql, queryParameters, dialect );

    PreparedStatement st = null;


    st = session.getTransactionCoordinator().getJdbcCoordinator().getStatementPreparer().prepareQueryStatement(
        sql,
        callable,
        scrollMode
    );

    try {

      int col = 1;
      //TODO: can we limit stored procedures ?!
      if ( useLimit && dialect.bindLimitParametersFirst() ) {
        col += bindLimitParameters( st, col, selection );
      }
      if (callable) {
        col = dialect.registerResultSetOutParameter( (CallableStatement)st, col );
      }

      col += bindParameterValues( st, queryParameters, col, session );

      if ( useLimit && !dialect.bindLimitParametersFirst() ) {
        col += bindLimitParameters( st, col, selection );
      }

      if ( !useLimit ) {
        setMaxRows( st, selection );
      }

      if ( selection != null ) {
        if ( selection.getTimeout() != null ) {
          st.setQueryTimeout( selection.getTimeout().intValue() );
        }
        if ( selection.getFetchSize() != null ) {
          st.setFetchSize( selection.getFetchSize().intValue() );
        }
      }

      // handle lock timeout...
      LockOptions lockOptions = queryParameters.getLockOptions();
      if ( lockOptions != null ) {
        if ( lockOptions.getTimeOut() != LockOptions.WAIT_FOREVER ) {
                    if (!dialect.supportsLockTimeouts()) LOG.debugf("Lock timeout [%s] requested but dialect reported to not support lock timeouts",
                                                                    lockOptions.getTimeOut());
                    else if (dialect.isLockTimeoutParameterized()) st.setInt(col++, lockOptions.getTimeOut());
        }
      }

      LOG.tracev( "Bound [{0}] parameters total", col );
    }
View Full Code Here

   */
  private int bindLimitParameters(
      final PreparedStatement statement,
      final int index,
      final RowSelection selection) throws SQLException {
    Dialect dialect = getFactory().getDialect();
    if ( !dialect.supportsVariableLimit() ) {
      return 0;
    }
    if ( !hasMaxRows( selection ) ) {
      throw new AssertionFailure( "no max results set" );
    }
    int firstRow = interpretFirstRow( getFirstRow( selection ) );
    int lastRow = getMaxOrLimit( selection, dialect );
    boolean hasFirstRow = dialect.supportsLimitOffset() && ( firstRow > 0 || dialect.forceLimitUsage() );
    boolean reverse = dialect.bindLimitParametersInReverseOrder();
    if ( hasFirstRow ) {
      statement.setInt( index + ( reverse ? 1 : 0 ), firstRow );
    }
    statement.setInt( index + ( reverse || !hasFirstRow ? 0 : 1 ), lastRow );
    return hasFirstRow ? 2 : 1;
View Full Code Here

          final SessionImplementor session)
  throws SQLException, HibernateException {

    ResultSet rs = null;
    try {
      Dialect dialect = getFactory().getDialect();
      rs = st.executeQuery();
      rs = wrapResultSetIfEnabled( rs , session );

      if ( !dialect.supportsLimitOffset() || !useLimit( selection, dialect ) ) {
        advance( rs, selection );
      }

      if ( autodiscovertypes ) {
        autoDiscoverTypes( rs );
View Full Code Here

        AvailableSettings.HBM2DDL_IMPORT_FILES,
        configuration.getProperties(),
        DEFAULT_IMPORT_FILE
    );

    final Dialect dialect = serviceRegistry.getService( JdbcServices.class ).getDialect();
    this.dropSQL = configuration.generateDropSchemaScript( dialect );
    this.createSQL = configuration.generateSchemaCreationScript( dialect );
  }
View Full Code Here

        AvailableSettings.HBM2DDL_IMPORT_FILES,
        serviceRegistry.getService( ConfigurationService.class ).getSettings(),
        DEFAULT_IMPORT_FILE
    );

    final Dialect dialect = jdbcServices.getDialect();
    this.dropSQL = metadata.getDatabase().generateDropSchemaScript( dialect );
    this.createSQL = metadata.getDatabase().generateSchemaCreationScript( dialect );
  }
View Full Code Here

   *
   * @deprecated properties may be specified via the Configuration object
   */
  @Deprecated
    public SchemaExport(Configuration configuration, Properties properties) throws HibernateException {
    final Dialect dialect = Dialect.getDialect( properties );

    Properties props = new Properties();
    props.putAll( dialect.getDefaultProperties() );
    props.putAll( properties );
    this.connectionHelper = new ManagedProviderConnectionHelper( props );

    this.sqlStatementLogger = new SqlStatementLogger( false, true );
    this.formatter = FormatStyle.DDL.getFormatter();
View Full Code Here

        AvailableSettings.HBM2DDL_IMPORT_FILES,
        configuration.getProperties(),
        DEFAULT_IMPORT_FILE
    );

    final Dialect dialect = Dialect.getDialect( configuration.getProperties() );
    this.dropSQL = configuration.generateDropSchemaScript( dialect );
    this.createSQL = configuration.generateSchemaCreationScript( dialect );
  }
View Full Code Here

    if ( type == null ) {
      throw new QueryException( QueryTranslator.ERROR_CANNOT_DETERMINE_TYPE + node.getText() );
    }
    try {
      LiteralType literalType = ( LiteralType ) type;
      Dialect dialect = walker.getSessionFactoryHelper().getFactory().getDialect();
      node.setText( literalType.objectToSQLString( value, dialect ) );
    }
    catch ( Exception e ) {
      throw new QueryException( QueryTranslator.ERROR_CANNOT_FORMAT_LITERAL + node.getText(), e );
    }
View Full Code Here

TOP

Related Classes of org.hibernate.dialect.Dialect

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.