Package org.hibernate.dialect

Examples of org.hibernate.dialect.Dialect


        typeResolver.registerTypeOverride( type, keys );
      }
    };

    // add Dialect contributed types
    final Dialect dialect = serviceRegistry.getService( JdbcServices.class ).getDialect();
    dialect.contributeTypes( typeContributions, serviceRegistry );

    // add TypeContributor contributed types.
    ClassLoaderService classLoaderService = serviceRegistry.getService( ClassLoaderService.class );
    for ( TypeContributor contributor : classLoaderService.loadJavaServices( TypeContributor.class ) ) {
      contributor.contribute( typeContributions, serviceRegistry );
View Full Code Here


          final String sql,
          final QueryParameters queryParameters,
          final LimitHandler limitHandler,
          final boolean scroll,
          final SessionImplementor session) throws SQLException, HibernateException {
    final Dialect dialect = getFactory().getDialect();
    final RowSelection selection = queryParameters.getRowSelection();
    boolean useLimit = LimitHelper.useLimit( limitHandler, selection );
    boolean hasFirstRow = LimitHelper.hasFirstRow( selection );
    boolean useLimitOffset = hasFirstRow && useLimit && limitHandler.supportsLimitOffset();
    boolean callable = queryParameters.isCallable();
    final ScrollMode scrollMode = getScrollMode( scroll, hasFirstRow, useLimitOffset, queryParameters );

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

    try {

      int col = 1;
      //TODO: can we limit stored procedures ?!
      col += limitHandler.bindLimitParametersAtStartOfQuery( st, col );

      if (callable) {
        col = dialect.registerResultSetOutParameter( (CallableStatement)st, col );
      }

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

      col += limitHandler.bindLimitParametersAtEndOfQuery( st, col );

      limitHandler.setMaxRows( st );

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

      // handle lock timeout...
      LockOptions lockOptions = queryParameters.getLockOptions();
      if ( lockOptions != null ) {
        if ( lockOptions.getTimeOut() != LockOptions.WAIT_FOREVER ) {
          if ( !dialect.supportsLockTimeouts() ) {
            if ( LOG.isDebugEnabled() ) {
              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() );
          }
        }
      }
View Full Code Here

      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

      processedPositionalParameterValues = getPositionalParameterValues();
      processedPositionalParameterTypes = getPositionalParameterTypes();
      processedSQL = sql;
    }
    else {
      final Dialect dialect = factory.getDialect();
      final String symbols = ParserHelper.HQL_SEPARATORS + dialect.openQuote() + dialect.closeQuote();
      final StringTokenizer tokens = new StringTokenizer( sql, symbols, true );

      StringBuilder result = new StringBuilder();
      List parameters = new ArrayList();
      List parameterTypes = new ArrayList();
View Full Code Here

      return determineDialect( resolutionInfoSource );
    }
  }

  private Dialect constructDialect(String dialectName) {
    final Dialect dialect;
    try {
      dialect = strategySelector.resolveStrategy( Dialect.class, dialectName );
      if ( dialect == null ) {
        throw new HibernateException( "Unable to construct requested dialect [" + dialectName+ "]" );
      }
View Full Code Here

    if ( resolutionInfoSource == null ) {
      throw new HibernateException( "Access to DialectResolutionInfo cannot be null when 'hibernate.dialect' not set" );
    }

    final DialectResolutionInfo info = resolutionInfoSource.getDialectResolutionInfo();
    final Dialect dialect = dialectResolver.resolveDialect( info );

    if ( dialect == null ) {
      throw new HibernateException(
          "Unable to determine Dialect to use [name=" + info.getDatabaseName() +
              ", majorVersion=" + info.getDatabaseMajorVersion() +
View Full Code Here

  @Override
  public Dialect resolveDialect(DialectResolutionInfo info) {
    for ( DialectResolver resolver : resolvers ) {
      try {
        final Dialect dialect = resolver.resolveDialect( info );
        if ( dialect != null ) {
          return dialect;
        }
      }
      catch ( JDBCConnectionException e ) {
View Full Code Here

    this( propertyName, matchMode.toMatchString( value ) );
  }

  @Override
  public String toSqlString(Criteria criteria, CriteriaQuery criteriaQuery) {
    final Dialect dialect = criteriaQuery.getFactory().getDialect();
    final String[] columns = criteriaQuery.findColumns( propertyName, criteria );
    if ( columns.length != 1 ) {
      throw new HibernateException( "ilike may only be used with single-column properties" );
    }
    if ( dialect instanceof PostgreSQLDialect || dialect instanceof PostgreSQL81Dialect) {
      return columns[0] + " ilike ?";
    }
    else {
      return dialect.getLowercaseFunction() + '(' + columns[0] + ") like ?";
    }
  }
View Full Code Here

        // apparently we also need to check that they are not already qualified.  Ugh!
        columnExpressions = StringHelper.qualifyIfNot( element.getTableAlias(), columnExpressions );
      }
    }

    final Dialect dialect = getWalker().getSessionFactoryHelper().getFactory().getDialect();
    final boolean isInCount = getWalker().isInCount();
    final boolean isInDistinctCount = isInCount && getWalker().isInCountDistinct();
    final boolean isInNonDistinctCount = isInCount && ! getWalker().isInCountDistinct();
    final boolean isCompositeValue = columnExpressions.length > 1;
    if ( isCompositeValue ) {
      if ( isInNonDistinctCount && ! dialect.supportsTupleCounts() ) {
        // TODO: #supportsTupleCounts currently false for all Dialects -- could this be cleaned up?
        setText( columnExpressions[0] );
      }
      else {
        String joinedFragment = StringHelper.join( ", ", columnExpressions );
        // avoid wrapping in parenthesis (explicit tuple treatment) if possible due to varied support for
        // tuple syntax across databases..
        final boolean shouldSkipWrappingInParenthesis =
            (isInDistinctCount && ! dialect.requiresParensForTupleDistinctCounts())
            || isInNonDistinctCount
            || getWalker().getCurrentTopLevelClauseType() == HqlSqlTokenTypes.ORDER
            || getWalker().getCurrentTopLevelClauseType() == HqlSqlTokenTypes.GROUP;
        if ( ! shouldSkipWrappingInParenthesis ) {
          joinedFragment = "(" + joinedFragment + ")";
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 metaSupportsRefCursors = false;
    boolean metaSupportsNamedParams = false;
    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;
    final 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).
    final boolean useJdbcMetadata = ConfigurationHelper.getBoolean( "hibernate.temp.use_jdbc_metadata_defaults", configValues, true );
    if ( useJdbcMetadata ) {
      try {
        final Connection connection = jdbcConnectionAccess.obtainConnection();
        try {
          final 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() );
          }

          metaSupportsRefCursors = StandardRefCursorSupport.supportsRefCursors( meta );
          metaSupportsNamedParams = meta.supportsNamedParameters();
          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( TypeInfo.extractTypeInfo( meta ) );

          dialect = dialectFactory.buildDialect(
              configValues,
              new DialectResolutionInfoSource() {
                @Override
                public DialectResolutionInfo getDialectResolutionInfo() {
                  try {
                    return new DatabaseMetaDataDialectResolutionInfoAdapter( connection.getMetaData() );
                  }
                  catch ( SQLException sqlException ) {
                    throw new HibernateException(
                        "Unable to access java.sql.DatabaseMetaData to determine appropriate Dialect to use",
                        sqlException
                    );
                  }
                }
              }
          );

          catalogName = connection.getCatalog();
          final 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.extractedMetaDataSupport = new ExtractedDatabaseMetaDataImpl(
        metaSupportsRefCursors,
        metaSupportsNamedParams,
        metaSupportsScrollable,
        metaSupportsGetGeneratedKeys,
        metaSupportsBatchUpdates,
        metaReportsDDLInTxnSupported,
        metaReportsDDLCausesTxnCommit,
        parseKeywords( extraKeywordsString ),
        parseSQLStateType( sqlStateType ),
        lobLocatorUpdateCopy,
        schemaName,
        catalogName,
        typeInfoSet
    );

    SQLExceptionConverter sqlExceptionConverter = dialect.buildSQLExceptionConverter();
    if ( sqlExceptionConverter == null ) {
      final StandardSQLExceptionConverter converter = new StandardSQLExceptionConverter();
      sqlExceptionConverter = converter;
      converter.addDelegate( dialect.buildSQLExceptionConversionDelegate() );
      converter.addDelegate( new SQLExceptionTypeDelegate( dialect ) );
      // todo : vary this based on extractedMetaDataSupport.getSqlStateType()
      converter.addDelegate( new SQLStateConversionDelegate( dialect ) );
    }
    this.sqlExceptionHelper = new SqlExceptionHelper( sqlExceptionConverter );
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.