HHH-8768 - Add support for OFFSET/FETCH syntax for SQL Server 2012 LimitHandler/pagination.

Author: Naros

hibernate-core/src/main/java/org/hibernate/dialect/SQLServer2012Dialect.java

@@ -8,6 +8,8 @@
 
 import java.util.List;
 
+import org.hibernate.dialect.pagination.LimitHandler;
+import org.hibernate.dialect.pagination.SQLServer2012LimitHandler;
 import org.hibernate.internal.util.StringHelper;
 
 /**
@@ -79,4 +81,14 @@ public String getQueryHintString(String sql, List<String> hints) {
 
 		return sql;
 	}
+
+	@Override
+	public boolean supportsLimitOffset() {
+		return true;
+	}
+
+	@Override
+	protected LimitHandler getDefaultLimitHandler() {
+		return SQLServer2012LimitHandler.INSTANCE;
+	}
 }

hibernate-core/src/main/java/org/hibernate/dialect/pagination/SQLServer2012LimitHandler.java

@@ -0,0 +1,67 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
+ * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
+ */
+package org.hibernate.dialect.pagination;
+
+import org.hibernate.engine.spi.RowSelection;
+
+/**
+ * LIMIT clause handler compatible with SQL Server 2012 and later.
+ *
+ * @author Chris Cranford
+ */
+public class SQLServer2012LimitHandler extends SQLServer2005LimitHandler {
+	public static final SQLServer2012LimitHandler INSTANCE = new SQLServer2012LimitHandler();
+
+	private SQLServer2012LimitHandler() {
+
+	}
+
+	@Override
+	public boolean supportsLimit() {
+		return true;
+	}
+
+	@Override
+	public boolean supportsVariableLimit() {
+		return false;
+	}
+
+	@Override
+	public String processSql(String sql, RowSelection selection) {
+		// SQLServer mandates the following rules to use OFFSET/LIMIT
+		//  * An 'ORDER BY' is required
+		//  * The 'OFFSET ...' clause is mandatory, cannot use 'FETCH ...' by itself.
+		//  * The 'TOP' clause isn't permitted with LIMIT/OFFSET.
+		if ( hasOrderBy( sql ) ) {
+			if ( !LimitHelper.useLimit( this, selection ) ) {
+				return sql;
+			}
+			int firstRow = LimitHelper.hasFirstRow( selection ) ? selection.getFirstRow() : 0;
+			return sql + String.format( " offset %d rows fetch next %d rows only", firstRow, selection.getMaxRows() );
+		}
+		return super.processSql( sql, selection );
+	}
+
+	private boolean hasOrderBy(String sql) {
+		int depth = 0;
+		for ( int i = 0; i < sql.length(); ++i ) {
+			char ch = sql.charAt( i );
+			if ( ch == '(' ) {
+				depth++;
+			}
+			else if ( ch == ')' ) {
+				depth--;
+			}
+			if ( depth == 0 ) {
+				if ( sql.substring( i ).toLowerCase().startsWith( "order by " ) ) {
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+}

hibernate-core/src/test/java/org/hibernate/dialect/SQLServer2012DialectTestCase.java

@@ -0,0 +1,91 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
+ * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
+ */
+package org.hibernate.dialect;
+
+import java.util.Locale;
+
+import org.hibernate.engine.spi.RowSelection;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import org.hibernate.testing.TestForIssue;
+import org.hibernate.testing.junit4.BaseUnitTestCase;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Tests the Limit/Offset handler for {@link SQLServer2012Dialect}.
+ *
+ * @author Chris Cranford
+ */
+public class SQLServer2012DialectTestCase extends BaseUnitTestCase {
+	private SQLServer2012Dialect dialect;
+
+	@Before
+	public void setup() {
+		dialect = new SQLServer2012Dialect();
+	}
+
+	@After
+	public void tearDown() {
+		dialect = null;
+	}
+
+	@Test
+	@TestForIssue(jiraKey = "HHH-8768")
+	public void testGetLimitStringMaxRowsOnly() {
+		final String input = "select distinct f1 as f53245 from table846752 order by f234, f67 desc";
+		assertEquals(
+				input + " offset 0 rows fetch next 10 rows only",
+				dialect.getLimitHandler().processSql( input, toRowSelection( 0, 10 ) ).toLowerCase( Locale.ROOT )
+		);
+	}
+
+	@Test
+	@TestForIssue(jiraKey = "HHH-8768")
+	public void testGetLimitStringWithOffsetAndMaxRows() {
+		final String input = "select distinct f1 as f53245 from table846752 order by f234, f67 desc";
+		assertEquals(
+				input + " offset 5 rows fetch next 25 rows only",
+				dialect.getLimitHandler().processSql( input, toRowSelection( 5, 25 ) ).toLowerCase( Locale.ROOT )
+		);
+	}
+
+	@Test
+	@TestForIssue(jiraKey = "HHH-8768")
+	public void testGetLimitStringMaxRowsOnlyNoOrderBy() {
+		// this test defaults back to validating result matches that from SQLServer2005LimitHandler
+		// See SQLServer2012LimitHandler for why this falls back
+		final String input = "select f1 from table";
+		assertEquals(
+				"select top(?) f1 from table",
+				dialect.getLimitHandler().processSql( input, toRowSelection( 0, 10 ) ).toLowerCase( Locale.ROOT )
+		);
+	}
+
+	@Test
+	@TestForIssue(jiraKey = "HHH-8768")
+	public void testGetLimitStringWithOffsetAndMaxRowsNoOrderBy() {
+		// this test defaults back to validating result matches that from SQLServer2005LimitHandler
+		// See SQLServer2012LimitHandler for why this falls back
+		final String input = "select f1 from table";
+		assertEquals(
+				"with query as (select inner_query.*, row_number() over (order by current_timestamp) as __hibernate_row_nr__ " +
+						"from ( select f1 as page0_ from table ) inner_query ) select page0_ from query where " +
+						"__hibernate_row_nr__ >= ? and __hibernate_row_nr__ < ?",
+				dialect.getLimitHandler().processSql( input, toRowSelection( 5, 10 ) ).toLowerCase( Locale.ROOT )
+		);
+	}
+
+	private RowSelection toRowSelection(int firstRow, int maxRows) {
+		final RowSelection selection = new RowSelection();
+		selection.setFirstRow( firstRow );
+		selection.setMaxRows( maxRows );
+		return selection;
+	}
+}