timestampColumnName

Last updated: September 2, 2025

timestampColumnName is a custom policy check that ensures all columns of a specified type include a postfix such as timestamp columns must include _ts at the end.

Learn how to create and customize the timestampColumnName Liquibase Custom Policy Check using a Python script.

This example works for relational databases. You can use this check as it is or customize it further to fit your needs in your SQL database.

For a conceptual overview of this feature, see Liquibase Secure Custom Policy Checks.

Before you begin

Scope	Database
database	Relational

Before you begin

Liquibase 4.29.0+
Python 3.10.14+
Configure a valid Liquibase Secure license key
Create a Check Settings file
Ensure the Liquibase Checks extension is installed. In Liquibase 4.31.0+, it is already installed in the /liquibase/internal/lib directory, so no action is needed.
If the checks JAR is not installed, download liquibase-checks-<version>.jar and put it in the liquibase/lib directory.
(Maven users only) Add the liquibase-checks dependency to your pom.xml file. See Add extensions with Maven for more information.
Java Development Kit 17+ (available for Open JDK and Oracle JDK)
Linux, macOS, or Windows operating system

Procedure

These steps describe how to create the Custom Policy Check. It does not exist by default in Liquibase Secure.

Add this code to your Checks Settings file:

timestampColumnName Python Script

# # #
# # # This script checks ensures that all columns of a specified type include a postfix
# # # e.g., timestamp columns must include _ts at the end
# # #
# # # Notes:
    # # #

# # #
# # # Helpers come from Liquibase
# # #
import liquibase_utilities
import sqlparse
import sys

# # #
# # # main
# # #

# # #
# # # Retrieve log handler
# # # Ex.liquibase_logger.info(message)
# # #
liquibase_logger = liquibase_utilities.get_logger()

# # #
# # # Retrieve status handler
# # #
liquibase_status = liquibase_utilities.get_status()

# # #
# # # Retrive column information from check definition
# # #
column_check = liquibase_utilities.get_arg("COLUMN_TYPE").casefold()
column_postfix = liquibase_utilities.get_arg("COLUMN_POSTFIX").casefold()

# # #
# # # Retrieve all changes in changeset
# # #
changes = liquibase_utilities.get_changeset().getChanges()

# # #
# # # Loop through all changes
# # #
for change in changes:
    # # #
# # # LoadData change types are not currently supported
# # #
if "loaddatachange" in change.getClass().getSimpleName().lower():
    liquibase_logger.info("LoadData change type not supported. Statement skipped.")
continue
# # #
# # # Retrieve sql as string, remove extra whitespace, split into statements
# # #
raw_sql = liquibase_utilities.strip_comments(liquibase_utilities.generate_sql(change)).casefold()
raw_sql = " ".join(raw_sql.split())
raw_statements = liquibase_utilities.split_statements(raw_sql)
# # #
# # # Process each statement
# # #
for raw_statement in raw_statements:
    column_list_detail = []
is_create, is_table = False, False
token_list = [token
    for token in liquibase_utilities.tokenize(raw_statement) if not token.is_whitespace
]
for token in token_list:
    if token.ttype == sqlparse.tokens.DDL and token.value == "create":
    is_create = True
elif is_create and token.ttype == sqlparse.tokens.Keyword and token.value == "table":
    is_table = True
elif is_create and is_table and token.value.startswith("("):
    columns = token.value[1: token.value.rfind(")")].replace("\n", "").split(",")
for column in columns:
    column_list_detail.append(' '.join(column.split()).split())
break
if (is_create == False or is_table == False):
    liquibase_logger.info(f "Non create table statement skipped: {raw_statement}")
continue
# # #
# # # Process column list
# # #
postfix_len = len(column_postfix)
for column in column_list_detail:
    column_name = column[0].replace("\"", "")
column_type = column[1]
if column_type == column_check and column_name[-postfix_len: ] != column_postfix:
    liquibase_status.fired = True
status_message = str(liquibase_utilities.get_script_message()).replace("__COLUMN_NAME__", f "\"{column_name}\"")
status_message = status_message.replace("__COLUMN_POSTFIX__", f "\"{column_postfix}\"")
liquibase_status.message = status_message
sys.exit(1)

# # #
# # # Default
return code
# # #
False

Initiate the customization process

A short name is a descriptive name that indicates what you want the check to search for in the database or changelog. In this example, we will provideSqlTruncateCheckas the short name, because we will be searching for any instances ofTruncate. The CLI will indicate that the new check was created fromSqlUserDefinedPatterncheck successfully:

New check 'SqlTruncateCheck' created from 'SqlUserDefinedPatternCheck'

Give your check a short name so you can easily identify what Python script it is associated with

Use up to 64 alpha-numeric characters only.

In this example we will name the check:

timestampColumnName

Set the Severity to return a code of 0-4 when triggered.

These severity codes allow you to determine if the job moves forward or stops when this check triggers. Learn more here: Use Policy Checks in Automation: Severity and Exit Code options: 'INFO'=0, 'MINOR'=1, 'MAJOR'=2, 'CRITICAL'=3, 'BLOCKER'=4

Set the SCRIPT_DESCRIPTION

In this example, we will set the description to:

This script ensures that all columns include _ts at the end.

Set the SCRIPT_SCOPE

In this example, we will set the scope to:

database: If your check looks for the presence of keys, indexes, or table name patterns in your database schema including Liquibase Tracking Tables. With this value, the check runs once for each database object.

Set the SCRIPT_MESSAGE

This message will display when the check is triggered. In this example we will use:

Column name __COLUMN_NAME__ must include __COLUMN_POSTFIX__. It is recommended this be fixed before proceeding.

Set the SCRIPT_PATH

This is the relative path where your script is stored in relation to the changelog specified in --changelog-file, whether it is stored locally or in a repository.

In this example, we will set the path to:

scripts/timestamp-column-name.py

Set the SCRIPT_ARGUMENT

COLUMN_TYPE=TIMESTAMP, COLUMN_POSTFIX=_TS

This allows you to pass dynamic information into the Custom Policy Check without modifying the Python code. When you set DATA_TYPE=CLOB in the CLI, you can retrieve it in your code with both of these variables:

column_type = liquibase_utilities.get_arg("COLUMN_TYPE") column_postfix = liquibase_utilities.get_arg("COLUMN_POSTFIX")

If you customize your check later, you can specify a new value in the CLI. If you don't need dynamic arguments, leave this field blank.

Set the REQUIRES_SNAPSHOT

If your script scope is changelog, set whether the check requires a database snapshot. Specify true if your check needs to inspect database objects.

If your script scope is database, Liquibase always takes a snapshot, so this prompt does not appear.

Note: The larger your database, the more performance impact a snapshot causes. If you cannot run a snapshot due to memory limitations, see Memory Limits of Inspecting Large Schemas.