Skip to content

Support for weak binding views to allow dropping of underlying objects#3806

Merged
forestkeeper merged 1 commit intobabelfish-for-postgresql:BABEL_5_X_DEVfrom
amazon-aurora:weak-view
Jul 11, 2025
Merged

Support for weak binding views to allow dropping of underlying objects#3806
forestkeeper merged 1 commit intobabelfish-for-postgresql:BABEL_5_X_DEVfrom
amazon-aurora:weak-view

Conversation

@R4hul04
Copy link
Copy Markdown
Contributor

@R4hul04 R4hul04 commented Jun 5, 2025

Description

Currently, Babelfish only supports strong binding for views, which prevents dropping or altering referenced objects when views depend on them. This behavior differs from SQL Server, which by default allows dropping underlying tables or views unless WITH SCHEMABINDING is explicitly specified.
With this change, Babelfish now supports configurable view binding modes:

  1. Strong binding (default): Prevents dropping referenced objects if views depend on them
  2. Weak binding: Allows dropping of referenced objects

This feature aligns Babelfish more closely with SQL Server's behavior, providing greater flexibility
Key aspects include:

  • A new GUC parameter babelfishpg_tsql.weak_view_binding to control the default binding behavior (default is false)
  • Support for explicit WITH SCHEMABINDING to create strongly bound views regardless of the GUC setting
  • Ability to create weakly bound views by default when the GUC is enabled
  • Proper handling of ALTER VIEW operations in both binding modes

In SQL Server, views are weakly bound by default, allowing underlying objects to be dropped or altered. With our implementation, users can now choose between SQL Server's default behavior (weak binding) or the previously enforced behavior (strong binding).

Important Limitation :

This implementation currently only addresses DROP operations on tables, views, functions, procedures as well as ALTER operations on views when these objects are bound by dependent views. ALTER TABLE/ ALTER FUNCTION operations (such as dropping columns or changing data types) are still restricted when dependent views exist, regardless of binding mode. This differs from SQL Server's behavior, where weak binding also allows ALTER operations on referenced objects.
When the same underlying object is recreated, its broken child view will get repaired only if it follows postgresql restrictions for CREATE OR REPLACE VIEW. [The new query must generate the same columns that were generated by the existing view query (that is, the same column names in the same order and with the same data types), but it may add additional columns to the end of the list]
https://www.postgresql.org/docs/current/sql-createview.html#:~:text=The%20new%20query,be%20completely%20different.

Issues Resolved

BABEL-1660

Signed-off-by: Rahul Parande rparande@amazon.com

Test Scenarios Covered

  • Use case based -
CREATE TABLE view_test.base_table1 ( id INT, name VARCHAR(50) );
GO

SELECT set_config('babelfishpg_tsql.weak_view_binding', 'true', false)
GO

set_config                                                                                                                                                                                                                                                      
------------
on

CREATE VIEW view_test.weak_view as select * from view_test.base_table1;
GO

DROP TABLE view_test.base_table1
GO

SELECT * FROM view_test.weak_view
GO
Msg 33557097, Level 16, State 1, Server BABELFISH, Line 1
relation "view_test.base_table1" does not exist

CREATE TABLE view_test.base_table1 ( id INT, name VARCHAR(50), address VARCHAR(50));
GO

SELECT * FROM view_test.weak_view
GO
id         name                                              
------ -------

SELECT * FROM view_test.weak_view
GO
id         name       address                                       
----- --------- -----------
CREATE TABLE view_test.base_table2 ( id INT, name VARCHAR(50));
GO

CREATE FUNCTION view_test.sample_function() RETURNS TABLE AS RETURN ( SELECT id, name FROM view_test.base_table2 );
GO

SELECT set_config('babelfishpg_tsql.weak_view_binding', 'true', false)
GO

CREATE VIEW view_test.weak_view_function AS SELECT * FROM view_test.sample_function();
GO

DROP FUNCTION view_test.sample_function();
GO

SELECT * FROM view_test.weak_view_function;
GO
Msg 33557097, Level 16, State 1, Server BABELFISH, Line 1
function view_test.sample_function() does not exist

-- Recreate the function 
CREATE FUNCTION view_test.sample_function() RETURNS TABLE AS RETURN ( SELECT id, name FROM view_test.base_table2 );
GO

SELECT * FROM view_test.weak_view_function;
GO
id        name 
----- --------
  • Boundary conditions -
-- Recreate the function which selects lesser columns that previous definition
CREATE FUNCTION view_test.sample_function() RETURNS TABLE AS RETURN ( SELECT id FROM view_test.base_table2 );
GO

SELECT * FROM view_test.weak_view_function;
GO
Msg 33557097, Level 16, State 1, Server BABELFISH, Line 1
cannot drop columns from view
CREATE TABLE t1 ( id INT IDENTITY(1,1) PRIMARY KEY, name TEXT NOT NULL );
GO

CREATE FUNCTION fnc_dependancy_check (@param1 NVARCHAR(100), @param2 NVARCHAR(100), @param3 NVARCHAR(100)) RETURNS NVARCHAR(300) AS BEGIN RETURN @param1 + ' - ' + @param2 + ' - ' + @param3; END;
GO

CREATE VIEW v1 AS SELECT id, fnc_dependancy_check(name, 'ex1', 'ex2') AS example FROM t1;
GO

DROP FUNCTION fnc_dependancy_check;
GO

-- Recreate the function with different input argument or different return parameter

CREATE FUNCTION fnc_dependancy_check (@param1 NVARCHAR(100), @param2 NVARCHAR(100), @param3 NVARCHAR(100)) RETURNS INT AS BEGIN RETURN @param1 + ' - ' + @param2 + ' - ' + @param3; END;

SELECT * FROM v1;
GO
Msg 33557097, Level 16, State 1, Server BABELFISH, Line 1
cannot change data type of view column "example" from nvarchar to integer
  • Arbitrary inputs -

  • Negative test cases -

  • Minor version upgrade tests -

  • Major version upgrade tests -

  • Performance tests -

  • Tooling impact -

  • Client tests -

Check List

  • Commits are signed per the DCO using --signoff

By submitting this pull request, I confirm that my contribution is under the terms of the Apache 2.0 and PostgreSQL licenses, and grant any person obtaining a copy of the contribution permission to relicense all or a portion of my contribution to the PostgreSQL License solely to contribute all or a portion of my contribution to the PostgreSQL open source project.

For more information on following Developer Certificate of Origin and signing off your commits, please check here.

@coveralls
Copy link
Copy Markdown
Collaborator

coveralls commented Jun 5, 2025

Pull Request Test Coverage Report for Build 16226896383

Details

  • 359 of 388 (92.53%) changed or added relevant lines in 7 files are covered.
  • No unchanged relevant lines lost coverage.
  • Overall coverage increased (+0.09%) to 76.022%

Changes Missing Coverage Covered Lines Changed/Added Lines %
contrib/babelfishpg_tsql/src/catalog.c 22 28 78.57%
contrib/babelfishpg_tsql/src/hooks.c 301 324 92.9%
Totals Coverage Status
Change from base Build 16219927312: 0.09%
Covered Lines: 49907
Relevant Lines: 65648

💛 - Coveralls

@R4hul04 R4hul04 marked this pull request as ready for review June 11, 2025 00:02
@R4hul04 R4hul04 requested a review from tanscorpio7 June 16, 2025 17:14
forestkeeper
forestkeeper previously approved these changes Jul 2, 2025
PG_END_TRY();
return;
}
/* check that no T-SQL ALTER VIEW operations reach this point because they should have been handled earlier in the code.*/
Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Who sets the flag for alter view case ?

@tanscorpio7 tanscorpio7 self-requested a review July 10, 2025 05:33
…s.This commit introduces support for both strong and weak view binding in Babelfish, aligning more closely with SQL Server's default behavior while maintaining flexibility.

Key changes:
- Introduce GUC parameter 'babelfishpg_tsql.weak_view_binding' to control default binding behavior (default: false)
- Support explicit WITH SCHEMABINDING clause for strong binding
- Implement weak binding to allow dropping of referenced objects
- Handle ALTER VIEW operations in both binding modes
- Add logic to repair broken views when underlying objects are recreated

Limitations:
- Only addresses DROP operations on tables, views, functions, and procedures
- ALTER TABLE/ALTER FUNCTION operations still restricted when dependent views exist
- View repair follows PostgreSQL's CREATE OR REPLACE VIEW restrictions

Signed-off-by: Rahul Parande <rparande@amazon.com>
@forestkeeper forestkeeper merged commit 012882b into babelfish-for-postgresql:BABEL_5_X_DEV Jul 11, 2025
47 checks passed
forestkeeper pushed a commit that referenced this pull request Jul 14, 2025
…s 5_3_STABLE (#3957)

Cherry picked commit from: #3806

Description

Currently, Babelfish only supports strong binding for views, which prevents dropping or altering referenced objects when views depend on them. This behavior differs from SQL Server, which by default allows dropping underlying tables or views unless WITH SCHEMABINDING is explicitly specified.
With this change, Babelfish now supports configurable view binding modes:

1. Strong binding (default): Prevents dropping referenced objects if views depend on them
2. Weak binding: Allows dropping of referenced objects

This feature aligns Babelfish more closely with SQL Server's behavior, providing greater flexibility
Key aspects include:

1. A new GUC parameter babelfishpg_tsql.weak_view_binding to control the default binding behavior (default is false)
2. Support for explicit WITH SCHEMABINDING to create strongly bound views regardless of the GUC setting
3. Ability to create weakly bound views by default when the GUC is enabled
4. Proper handling of ALTER VIEW operations in both binding modes

In SQL Server, views are weakly bound by default, allowing underlying objects to be dropped or altered. With our implementation, users can now choose between SQL Server's default behavior (weak binding) or the previously enforced behavior (strong binding).

Important Limitation :
This implementation currently only addresses DROP operations on tables, views, functions, procedures as well as ALTER operations on views when these objects are bound by dependent views. ALTER TABLE/ ALTER FUNCTION operations (such as dropping columns or changing data types) are still restricted when dependent views exist, regardless of binding mode. This differs from SQL Server's behavior, where weak binding also allows ALTER operations on referenced objects.
When the same underlying object is recreated, its broken child view will get repaired only if it follows postgresql restrictions for CREATE OR REPLACE VIEW. [The new query must generate the same columns that were generated by the existing view query (that is, the same column names in the same order and with the same data types), but it may add additional columns to the end of the list]
https://www.postgresql.org/docs/current/sql-createview.html#:~:text=The%20new%20query,be%20completely%20different.

Issues Resolved: BABEL-1660
Signed-off-by: Rahul Parande rparande@amazon.com
R4hul04 added a commit to amazon-aurora/babelfish_extensions that referenced this pull request Jul 14, 2025
…s.This commit introduces support for both strong and weak view binding in Babelfish, aligning more closely with SQL Server's default behavior while maintaining flexibility. (babelfish-for-postgresql#3806)

Description
Currently, Babelfish only supports strong binding for views, which prevents dropping or altering referenced objects when views depend on them. This behavior differs from SQL Server, which by default allows dropping underlying tables or views unless WITH SCHEMABINDING is explicitly specified.
With this change, Babelfish now supports configurable view binding modes:

Strong binding (default): Prevents dropping referenced objects if views depend on them
Weak binding: Allows dropping of referenced objects
This feature aligns Babelfish more closely with SQL Server's behavior, providing greater flexibility
Key aspects include:

A new GUC parameter babelfishpg_tsql.weak_view_binding to control the default binding behavior (default is false)
Support for explicit WITH SCHEMABINDING to create strongly bound views regardless of the GUC setting
Ability to create weakly bound views by default when the GUC is enabled
Proper handling of ALTER VIEW operations in both binding modes
In SQL Server, views are weakly bound by default, allowing underlying objects to be dropped or altered. With our implementation, users can now choose between SQL Server's default behavior (weak binding) or the previously enforced behavior (strong binding).

Important Limitation :
This implementation currently only addresses DROP operations on tables, views, functions, procedures as well as ALTER operations on views when these objects are bound by dependent views. ALTER TABLE/ ALTER FUNCTION operations (such as dropping columns or changing data types) are still restricted when dependent views exist, regardless of binding mode. This differs from SQL Server's behavior, where weak binding also allows ALTER operations on referenced objects.
When the same underlying object is recreated, its broken child view will get repaired only if it follows postgresql restrictions for CREATE OR REPLACE VIEW. [The new query must generate the same columns that were generated by the existing view query (that is, the same column names in the same order and with the same data types), but it may add additional columns to the end of the list]
https://www.postgresql.org/docs/current/sql-createview.html#:~:text=The%20new%20query,be%20completely%20different.

Issues Resolved
BABEL-1660

Signed-off-by: Rahul Parande <rparande@amazon.com>
R4hul04 added a commit to amazon-aurora/babelfish_extensions that referenced this pull request Jul 15, 2025
…s.This commit introduces support for both strong and weak view binding in Babelfish, aligning more closely with SQL Server's default behavior while maintaining flexibility. (babelfish-for-postgresql#3806)

Description
Currently, Babelfish only supports strong binding for views, which prevents dropping or altering referenced objects when views depend on them. This behavior differs from SQL Server, which by default allows dropping underlying tables or views unless WITH SCHEMABINDING is explicitly specified.
With this change, Babelfish now supports configurable view binding modes:

Strong binding (default): Prevents dropping referenced objects if views depend on them
Weak binding: Allows dropping of referenced objects
This feature aligns Babelfish more closely with SQL Server's behavior, providing greater flexibility
Key aspects include:

A new GUC parameter babelfishpg_tsql.weak_view_binding to control the default binding behavior (default is false)
Support for explicit WITH SCHEMABINDING to create strongly bound views regardless of the GUC setting
Ability to create weakly bound views by default when the GUC is enabled
Proper handling of ALTER VIEW operations in both binding modes
In SQL Server, views are weakly bound by default, allowing underlying objects to be dropped or altered. With our implementation, users can now choose between SQL Server's default behavior (weak binding) or the previously enforced behavior (strong binding).

Important Limitation :
This implementation currently only addresses DROP operations on tables, views, functions, procedures as well as ALTER operations on views when these objects are bound by dependent views. ALTER TABLE/ ALTER FUNCTION operations (such as dropping columns or changing data types) are still restricted when dependent views exist, regardless of binding mode. This differs from SQL Server's behavior, where weak binding also allows ALTER operations on referenced objects.
When the same underlying object is recreated, its broken child view will get repaired only if it follows postgresql restrictions for CREATE OR REPLACE VIEW. [The new query must generate the same columns that were generated by the existing view query (that is, the same column names in the same order and with the same data types), but it may add additional columns to the end of the list]
https://www.postgresql.org/docs/current/sql-createview.html#:~:text=The%20new%20query,be%20completely%20different.

Issues Resolved
BABEL-1660

Signed-off-by: Rahul Parande <rparande@amazon.com>
jsudrik pushed a commit that referenced this pull request Jul 15, 2025
…s BABEL_4_7_STABLE (#3966)

* Support for weak binding views to allow dropping of underlying objects.This commit introduces support for both strong and weak view binding in Babelfish, aligning more closely with SQL Server's default behavior while maintaining flexibility. (#3806)

Description
Currently, Babelfish only supports strong binding for views, which prevents dropping or altering referenced objects when views depend on them. This behavior differs from SQL Server, which by default allows dropping underlying tables or views unless WITH SCHEMABINDING is explicitly specified.
With this change, Babelfish now supports configurable view binding modes:

Strong binding (default): Prevents dropping referenced objects if views depend on them
Weak binding: Allows dropping of referenced objects
This feature aligns Babelfish more closely with SQL Server's behavior, providing greater flexibility
Key aspects include:

A new GUC parameter babelfishpg_tsql.weak_view_binding to control the default binding behavior (default is false)
Support for explicit WITH SCHEMABINDING to create strongly bound views regardless of the GUC setting
Ability to create weakly bound views by default when the GUC is enabled
Proper handling of ALTER VIEW operations in both binding modes
In SQL Server, views are weakly bound by default, allowing underlying objects to be dropped or altered. With our implementation, users can now choose between SQL Server's default behavior (weak binding) or the previously enforced behavior (strong binding).

Important Limitation :
This implementation currently only addresses DROP operations on tables, views, functions, procedures as well as ALTER operations on views when these objects are bound by dependent views. ALTER TABLE/ ALTER FUNCTION operations (such as dropping columns or changing data types) are still restricted when dependent views exist, regardless of binding mode. This differs from SQL Server's behavior, where weak binding also allows ALTER operations on referenced objects.
When the same underlying object is recreated, its broken child view will get repaired only if it follows postgresql restrictions for CREATE OR REPLACE VIEW. [The new query must generate the same columns that were generated by the existing view query (that is, the same column names in the same order and with the same data types), but it may add additional columns to the end of the list]
https://www.postgresql.org/docs/current/sql-createview.html#:~:text=The%20new%20query,be%20completely%20different.

Issues Resolved
BABEL-1660

* Fix crash during tuple update for broken view by registering an active transaction snapshot

* Trigger Build

---------

Signed-off-by: Rahul Parande <rparande@amazon.com>
Co-authored-by: Rahul Parande <rparande@amazon.com>
jsudrik pushed a commit that referenced this pull request Jul 15, 2025
…s BABEL_4_X_DEV (#3965)

* Support for weak binding views to allow dropping of underlying objects.This commit introduces support for both strong and weak view binding in Babelfish, aligning more closely with SQL Server's default behavior while maintaining flexibility. (#3806)

Description
Currently, Babelfish only supports strong binding for views, which prevents dropping or altering referenced objects when views depend on them. This behavior differs from SQL Server, which by default allows dropping underlying tables or views unless WITH SCHEMABINDING is explicitly specified.
With this change, Babelfish now supports configurable view binding modes:

Strong binding (default): Prevents dropping referenced objects if views depend on them
Weak binding: Allows dropping of referenced objects
This feature aligns Babelfish more closely with SQL Server's behavior, providing greater flexibility
Key aspects include:

A new GUC parameter babelfishpg_tsql.weak_view_binding to control the default binding behavior (default is false)
Support for explicit WITH SCHEMABINDING to create strongly bound views regardless of the GUC setting
Ability to create weakly bound views by default when the GUC is enabled
Proper handling of ALTER VIEW operations in both binding modes
In SQL Server, views are weakly bound by default, allowing underlying objects to be dropped or altered. With our implementation, users can now choose between SQL Server's default behavior (weak binding) or the previously enforced behavior (strong binding).

Important Limitation :
This implementation currently only addresses DROP operations on tables, views, functions, procedures as well as ALTER operations on views when these objects are bound by dependent views. ALTER TABLE/ ALTER FUNCTION operations (such as dropping columns or changing data types) are still restricted when dependent views exist, regardless of binding mode. This differs from SQL Server's behavior, where weak binding also allows ALTER operations on referenced objects.
When the same underlying object is recreated, its broken child view will get repaired only if it follows postgresql restrictions for CREATE OR REPLACE VIEW. [The new query must generate the same columns that were generated by the existing view query (that is, the same column names in the same order and with the same data types), but it may add additional columns to the end of the list]
https://www.postgresql.org/docs/current/sql-createview.html#:~:text=The%20new%20query,be%20completely%20different.

Issues Resolved
BABEL-1660

* Fix crash during tuple update for broken view by registering an active transaction snapshot

---------

Signed-off-by: Rahul Parande <rparande@amazon.com>
Co-authored-by: Rahul Parande <rparande@amazon.com>
sharathbp pushed a commit to amazon-aurora/babelfish_extensions that referenced this pull request Sep 22, 2025
…s BABEL_4_X_DEV (babelfish-for-postgresql#3965)

* Support for weak binding views to allow dropping of underlying objects.This commit introduces support for both strong and weak view binding in Babelfish, aligning more closely with SQL Server's default behavior while maintaining flexibility. (babelfish-for-postgresql#3806)

Description
Currently, Babelfish only supports strong binding for views, which prevents dropping or altering referenced objects when views depend on them. This behavior differs from SQL Server, which by default allows dropping underlying tables or views unless WITH SCHEMABINDING is explicitly specified.
With this change, Babelfish now supports configurable view binding modes:

Strong binding (default): Prevents dropping referenced objects if views depend on them
Weak binding: Allows dropping of referenced objects
This feature aligns Babelfish more closely with SQL Server's behavior, providing greater flexibility
Key aspects include:

A new GUC parameter babelfishpg_tsql.weak_view_binding to control the default binding behavior (default is false)
Support for explicit WITH SCHEMABINDING to create strongly bound views regardless of the GUC setting
Ability to create weakly bound views by default when the GUC is enabled
Proper handling of ALTER VIEW operations in both binding modes
In SQL Server, views are weakly bound by default, allowing underlying objects to be dropped or altered. With our implementation, users can now choose between SQL Server's default behavior (weak binding) or the previously enforced behavior (strong binding).

Important Limitation :
This implementation currently only addresses DROP operations on tables, views, functions, procedures as well as ALTER operations on views when these objects are bound by dependent views. ALTER TABLE/ ALTER FUNCTION operations (such as dropping columns or changing data types) are still restricted when dependent views exist, regardless of binding mode. This differs from SQL Server's behavior, where weak binding also allows ALTER operations on referenced objects.
When the same underlying object is recreated, its broken child view will get repaired only if it follows postgresql restrictions for CREATE OR REPLACE VIEW. [The new query must generate the same columns that were generated by the existing view query (that is, the same column names in the same order and with the same data types), but it may add additional columns to the end of the list]
https://www.postgresql.org/docs/current/sql-createview.html#:~:text=The%20new%20query,be%20completely%20different.

Issues Resolved
BABEL-1660

* Fix crash during tuple update for broken view by registering an active transaction snapshot

---------

Signed-off-by: Rahul Parande <rparande@amazon.com>
Co-authored-by: Rahul Parande <rparande@amazon.com>
Yvinayak07 pushed a commit to amazon-aurora/babelfish_extensions that referenced this pull request Oct 15, 2025
…s BABEL_4_X_DEV (babelfish-for-postgresql#3965)

* Support for weak binding views to allow dropping of underlying objects.This commit introduces support for both strong and weak view binding in Babelfish, aligning more closely with SQL Server's default behavior while maintaining flexibility. (babelfish-for-postgresql#3806)

Description
Currently, Babelfish only supports strong binding for views, which prevents dropping or altering referenced objects when views depend on them. This behavior differs from SQL Server, which by default allows dropping underlying tables or views unless WITH SCHEMABINDING is explicitly specified.
With this change, Babelfish now supports configurable view binding modes:

Strong binding (default): Prevents dropping referenced objects if views depend on them
Weak binding: Allows dropping of referenced objects
This feature aligns Babelfish more closely with SQL Server's behavior, providing greater flexibility
Key aspects include:

A new GUC parameter babelfishpg_tsql.weak_view_binding to control the default binding behavior (default is false)
Support for explicit WITH SCHEMABINDING to create strongly bound views regardless of the GUC setting
Ability to create weakly bound views by default when the GUC is enabled
Proper handling of ALTER VIEW operations in both binding modes
In SQL Server, views are weakly bound by default, allowing underlying objects to be dropped or altered. With our implementation, users can now choose between SQL Server's default behavior (weak binding) or the previously enforced behavior (strong binding).

Important Limitation :
This implementation currently only addresses DROP operations on tables, views, functions, procedures as well as ALTER operations on views when these objects are bound by dependent views. ALTER TABLE/ ALTER FUNCTION operations (such as dropping columns or changing data types) are still restricted when dependent views exist, regardless of binding mode. This differs from SQL Server's behavior, where weak binding also allows ALTER operations on referenced objects.
When the same underlying object is recreated, its broken child view will get repaired only if it follows postgresql restrictions for CREATE OR REPLACE VIEW. [The new query must generate the same columns that were generated by the existing view query (that is, the same column names in the same order and with the same data types), but it may add additional columns to the end of the list]
https://www.postgresql.org/docs/current/sql-createview.html#:~:text=The%20new%20query,be%20completely%20different.

Issues Resolved
BABEL-1660

* Fix crash during tuple update for broken view by registering an active transaction snapshot

---------

Signed-off-by: Rahul Parande <rparande@amazon.com>
Co-authored-by: Rahul Parande <rparande@amazon.com>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

4 participants