What is In-memory Database?

Database Theory: What is In-memory Database?

What is Hekaton in SQL Server 2014?

SQL Server 2014: What is Hekaton?

How to create memory optimized table in SQL Server 2014?

SQL Server 2014: Create Memory Optimized File Group and Table

I want to turn the unique record from multiple rows to multiple column values. Is it possible in SQL Server?

Yes, We can do this task using PIVOT.

SQL Server has a PIVOT relational operator to turn the unique values of a specified column from multiple rows into multiple column values in the output (cross-tab), effectively rotating a table. It also allows performing aggregations, wherever required, for column values that are expected in the final output. The basic syntax for a PIVOT relational operator looks like this:

SELECT [ColumnNames] FROM [TableName]
PIVOT
(
AggregateFunction([ColumnToBeAggregated])
FOR PivotColumn IN ([PivotColumnValues])
) AS Alias

Do you know about the UNPIVOT?

UNPIVOT is another relational operator in SQL Server that performs almost the reverse operation of PIVOT, by rotating column values into rows values.

Using UNPIVOT, Do you think that you can get all correct value which are pivoted using PIVOT?

If you refer back, I said UNPIVOT is almost the reverse of the PIVOT operator; this means it might or might not be exactly the same. The reason is, Pivot performs aggregation while rotating row values into column values and might merge possible multiple row values into single column value in the output.

What is the WITH CHECK OPTION clause for a view?

The WITH CHECK OPTION for a view prevents data modifications (to the data) that do not confirm to the WHERE clause of the view definition. This allows data to be updated via the view, but only if it belongs in the view.

How you are checking that record is exists in database or not?

Using EXISTS clause:

IF EXISTS(SELECT 1 FROM dbo.Customer WITH(NOLOCK) WHERE CustId = @CustId)
    BEGIN
        PRINT 'Record Exists'
    END
ELSE
    BEGIN
        PRINT 'Record doesn''t Exists'
    END
END IF;

What is the meaning of the WITH SCHEMABINDING clause?

• SCHEMABINDING binds the view to the schema of the underlying table or tables. When SCHEMABINDING is specified, the base table or tables cannot be modified in a way that would affect the view definition.
• The view definition itself must first be modified or dropped to remove dependencies on the table that is to be modified.
• All referenced objects must be in the same database. Views or tables that participate in a view created with the SCHEMABINDING clause cannot be dropped unless that view is dropped or changed so that it no longer has schema binding. Otherwise, the Database Engine raises an error.
• Also, executing ALTER TABLE statements on tables that participate in views that have schema binding fail when these statements affect the view definition.
• The implementation of SCHEMABINDING would increase stability and performance of the system, but also increase the amount of developers’ work.

Can we use WITH SCHEMABINDING in Stored Procedures?

No: We cannot use WITH SCHEMABINDING in stored procedures.

What are the main disadvantages of the WITH SCHEMABINDING clause?

It would take more time to make changes in tables’ structure. If I just want to change the size of one column, I will need to modify before and after several views.

The automated test of the application can catch all broken views and functions. This will not increase the amount of developers’ work.

You can not change the collation of a database with schemabound objects.

What do you know about the OFFSET FETCH clause of the SQL Server 2012?

The OFFSET-FETCH clause provides you with an option to fetch only a window or page of results from the result set. OFFSET-FETCH can be used only with the ORDER BY clause.

OFFSET: Specifies the number of rows to skip, before starting to return rows from the query expression. The argument for the OFFSET clause can be an integer or expression that is greater than or equal to zero. You can use ROW and ROWS interchangeably.

FETCH: Specifies the number of rows to return, after processing the OFFSET clause. The argument for the FETCH clause can be an integer or expression that is greater than or equal to one. You can use ROW and ROWS interchangeably. Similarly, FIRST and NEXT can be used interchangeably.

Please write a script or logic of custom paging using OFFSET and FETCH NEXT.

SQL Server 2012: Custom paging using OFFSET and FETCH NEXT

What are the limitations of OFFSET and FETCH clause of the SQL Server 2012?

• ORDER BY is mandatory to use OFFSET and FETCH clause.
• OFFSET clause is mandatory with FETCH. You can never use, ORDER BY … FETCH.
• TOP cannot be combined with OFFSET and FETCH in the same query expression.
• The OFFSET/FETCH rowcount expression can be any arithmetic, constant, or parameter expression that will return an integer value. The rowcount expression does not support scalar sub-queries.

What is the maximum size of a VARCHAR(MAX) variable?

Maximum size of a VARCHAR(MAX) is 2GB.

What is BCP? When is it used?

It is a tool used to duplicate enormous quantity of information from tables and views. It does not facsimile the structures same as foundation to target. BULK INSERT command helps to bring in a data folder into a record, table or view in a user-specific arrangement.

When is the Explicit Cursor Used ?

If the developer needs to perform the row by row operations for the result set containing more than one row, then he unambiguously declares a pointer with a name. They are managed by OPEN, FETCH and CLOSE.

%FOUND, %NOFOUND, %ROWCOUNT and %ISOPEN characteristics are used in all types of pointers.

How can a SQL Developer prevent T-SQL code from running on a production SQL Server?

Use IF logic with the @@SERVERNAME function compared against a string with a RETURN command before any other logic.

Can you create foreign key constraints on temporary tables?

No: You cannot create a foreign key constraint on temporary tables.

In this post, I am sharing a demo on SQL Server 2012 Pagination or Custom paging query using OFFSET and FETCH.

Whenever thousands or millions of rows are returning from a database at that time paging is required.
Using custom paging, we can return only limited data for a particular page.

For example, database stored procedure returned 10,00,00 records at one call. How can you arrange this many data into the application grid or any report?

In this kind of requirement, database paging is playing an important role.
The Application has to call a stored procedure using two main parameters:

Page number
Page size

SQL Server 2012 introduced powerful FETCH and OFFSET features.

FETCH and OFFSET retires only small portion of rows from the primary result set.

Using FETCH, you can set a total number of rows.

Using OFFSET, you can skip some rows.

First, create a sample table and insert sample 10000 records.

CREATE TABLE tbl_SamplePaging 
(
	EmpID INT IDENTITY(1,1)
	,EmpName VARCHAR(250)
)
GO

INSERT INTO tbl_SamplePaging(EmpName) 
VALUES ('ABCD' + CAST((SELECT MAX(EmpID) FROM tbl_SamplePaging) AS VARCHAR))
GO 10000

The custom paging query using PageSize and PageNumber parameters:

DECLARE
  @PageSize INT = 10,
  @PageNumber  INT = 1;

SELECT 
	COUNT(1) OVER() AS TotalCount
	,EmpID
	,EmpName	
FROM tbl_SamplePaging
ORDER BY EmpID 
	OFFSET (@PageNumber-1)*@PageSize ROWS
	FETCH NEXT @PageSize ROWS ONLY

The result of first page with 10 records:

In this post, I am going to demonstrate the PostgreSQL Pagination or Custom paging query using OFFSET and LIMIT.

Whenever thousands or millions of rows are returning from the database at that time paging is required.

Using custom paging we can return only limited data for a particular page.

For example, database stored procedure returned 10,00,00 records at one call.
How can you arrange this many data into the application grid or any report?

In this kind of requirement, database paging is playing an important role.

The Application has to call a stored procedure using two primary parameters.

Page number
Page size

PostgreSQL provides powerful LIMIT and OFFSET features.

LIMIT and OFFSET fetches only small portion of rows from a primary the result set.

Using LIMIT you can set a total number of rows which are limited.

Using OFFSET you can skip a number of rows which number is defined by OFFSET.

For more details please visit this official document.

Below is a stored function for Custom Paging.

Below, is a created one Employee table with 10 rows.

CREATE TABLE Employee
(
 EmpID SERIAL
 ,EmpName CHARACTER VARYING(50)
 ,Gender CHAR(1)
 ,AGE SMALLINT
);
INSERT INTO Employee 
(
 EmpName 
 ,Gender 
 ,AGE 
)
VALUES 
 ('Anvesh','M',27)
 ,('Mohan','M',30)
 ,('Roy','M',31)
 ,('Meera','F',27)
 ,('Richa','F',26)
 ,('Martin','M',35)
 ,('Mahesh','M',38)
 ,('Paresh','M',22)
 ,('Alina','F',21)
 ,('Alex','M',24);

Below is custom paging stored procedure:

CREATE OR REPLACE FUNCTION fn_GetEmployeeData
(
 Paging_PageSize INTEGER = NULL
 ,Paging_PageNumber INTEGER = NULL   
)
RETURNS TABLE 
( 
 outEmpID INTEGER
 ,outEmpName CHARACTER VARYING
 ,outGender CHAR(1)
 ,outAge SMALLINT
) AS
$BODY$
DECLARE PageNumber BIGINT;
 
BEGIN
 /* ***************************************************************
 Construct Custom paging parameter...
 **************************************************************** */
 IF (paging_pagesize IS NOT NULL AND paging_pagenumber IS NOT NULL) THEN
  PageNumber := (Paging_PageSize * (Paging_PageNumber-1)); 
 END IF; 
  
 /* ************************************************
 Custome paging SQL Query construction.......
 ************************************************ */
 RETURN QUERY
 SELECT
  EmpID
  ,EmpName
  ,Gender
  ,Age
 FROM public.Employee
 ORDER BY EmpID
 LIMIT Paging_PageSize
 OFFSET PageNumber; 

 EXCEPTION WHEN OTHERS THEN 
 RAISE;
END;
$BODY$
LANGUAGE 'plpgsql';

Now execute some sample:

SELECT *FROM public.fn_GetEmployeeData(2,2)

SELECT *FROM public.fn_GetEmployeeData(4,2)

Above sample only return four row at second page, mean row number 5 to 8

Please Note:
Whenever you are using LIMIT at that time do not forget to use default ORDER BY which helps LIMIT to restricting data into a particular order.