Redshift Schema

datashare

The datashare block describes a datashare created in this database, and the consumers granted access to it. A function is shared by name: Redshift does not report which of its overloads a datashare holds, so every overload is added to and removed from the share together.

datashare "sales_share" {
  public_accessible = false
  schema {
    for     = schema.sales
    objects = [table.orders, view.summary]
  }
  schema {
    for         = schema.logs
    include_new = true
  }
  schema {
    for                = schema.events
    include_new_except = [table.audit]
  }
  namespaces = ["00000000-0000-0000-0000-000000000000"]
  accounts   = ["000000000000"]
}

datashare attributes

Name and description	Required	Value
accounts AWS account IDs of the consumers granted usage on the datashare. Used for a consumer in another account, which then grants its own namespaces.	false	List of strings
namespaces Namespace identifiers of the consumers granted usage on the datashare. Used for a consumer in the same AWS account.	false	List of strings
public_accessible	false	bool

datashare blocks

datashare.schema

A schema shared by the datashare, and the objects shared from it.

datashare.schema attributes

Name and description	Required	Value
for	true	Schema reference or name can be one of: Object reference to schema string
include_new Share every object of the schema, including the ones created later. Redshift shares only the objects created after this is set, so the ones that already exist are shared by Atlas.	false	bool
include_new_except Share every object of the schema except these. Implies include_new.	false	List of values, where each can be one of: Object reference to table Object reference to view Object reference to materialized Object reference to function
objects	false	List of values, where each can be one of: Object reference to table Object reference to view Object reference to materialized Object reference to function string

datashare.schema blocks

datashare.schema.annotation

datashare.schema.annotation constraints

Constraint	Value
Required	false
Require Name	false
Allow unknown blocks	true
Allow unknown attributes	true

datashare.schema constraints

Constraint	Value
Required	false
Require Name	false
Repeatable	true
Mutually exclusive sets	[objects, include_new, include_new_except]

datashare constraints

Constraint	Value
Required	false
Require Name (e.g., datashare "name" )	true
One of required sets	[namespaces, accounts]

function

The function block describes a function in a database schema.

function "positive" {
  schema = schema.public
  lang   = SQL
  arg "v" {
    type = integer
  }
  ...
}

function attributes

Name	Required	Value
as	true	string
depends_on	false	List of object references
lang	true	Function language can be one of: string enum (SQL)
return	false	Function return type can be one of: Schema type Raw expression defined with sql("expr")
schema	true	Object reference to schema
volatility	false	enum (VOLATILE, STABLE, IMMUTABLE)

function blocks

function.annotation

function.annotation constraints

Constraint	Value
Required	false
Require Name	false
Allow unknown blocks	true
Allow unknown attributes	true

function.arg

function.arg attributes

Name	Required	Value
type	true	Function argument type can be one of: Schema type Raw expression defined with sql("expr")

function.arg constraints

Constraint	Value
Required	false
Require Name	false
Repeatable	true

function constraints

Constraint	Value
Required	false
Require Name (e.g., function "name" )	true
Allow Qualifier (e.g., function "schema" "name" )	true
Repeatable	true

materialized

The materialized block describes a materialized view in a database schema.

materialized "name" {
  schema = schema.public
  column "total" {
    null = true
    type = numeric
  }
  ...
}

materialized attributes

Name	Required	Value
as	true	string
auto_refresh	false	bool
comment	false	string
depends_on	false	List of object references
schema	true	Object reference to schema

materialized blocks

materialized.annotation

materialized.annotation constraints

Constraint	Value
Required	false
Require Name	false
Allow unknown blocks	true
Allow unknown attributes	true

materialized.column

materialized.column attributes

Name	Required	Value
comment	false	string
null	false	bool
type	true	Column type can be one of: Schema type Raw expression defined with sql("expr")

materialized.column blocks

materialized.column.annotation

materialized.column.annotation constraints

Constraint	Value
Required	false
Require Name	false
Allow unknown blocks	true
Allow unknown attributes	true

materialized.column constraints

Constraint	Value
Required	false
Require Name (e.g., materialized.column "name" )	true

materialized.distribution

materialized.distribution attributes

Name	Required	Value
column	false	Object reference
style	false	enum (EVEN, ALL, KEY)

materialized.sort

materialized.sort attributes

Name	Required	Value
columns	false	List of object reference to column
style	false	enum (COMPOUND)

materialized constraints

Constraint	Value
Required	false
Require Name (e.g., materialized "name" )	true
Allow Qualifier (e.g., materialized "schema" "name" )	true

permission

The permission block describes privileges granted on database objects.

permission {
  to         = user.app
  for        = table.users
  privileges = [SELECT]
}

permission attributes

Name	Required	Value
for	true	Permission target resource can be one of: Object reference to schema Object reference to table Object reference to view Object reference to materialized Object reference to function Object reference to procedure Object reference to table.column Object reference to view.column Object reference to materialized.column
grantable	false	bool
privileges	true	List of strings or/and enums (SELECT, INSERT, UPDATE, DELETE, DROP, REFERENCES, TRUNCATE, ALTER, TRIGGER, RULE, CREATE, USAGE, EXECUTE, ALL)
to	true	Permission grantee can be one of: string Object reference to role Object reference to user

permission constraints

Constraint	Value
Required	false
Require Name	false
Repeatable	true

procedure

The procedure block describes a procedure in a database schema.

procedure "proc" {
  schema = schema.public
  lang   = SQL
  arg "a" {
    type = integer
  }
  ...
}

procedure attributes

Name	Required	Value
as	true	string
depends_on	false	List of object references
lang	true	Procedure language can be one of: string enum (SQL) enum (PLpgSQL)
schema	true	Object reference to schema
security	false	enum (DEFINER, INVOKER)

procedure blocks

procedure.annotation

procedure.annotation constraints

Constraint	Value
Required	false
Require Name	false
Allow unknown blocks	true
Allow unknown attributes	true

procedure.arg

procedure.arg attributes

Name	Required	Value
mode	false	Procedure argument mode can be one of: string enum (IN, OUT, INOUT)
type	true	Procedure argument type can be one of: Schema type Raw expression defined with sql("expr")

procedure.arg constraints

Constraint	Value
Required	false
Require Name	false
Repeatable	true

procedure constraints

Constraint	Value
Required	false
Require Name (e.g., procedure "name" )	true
Allow Qualifier (e.g., procedure "schema" "name" )	true
Repeatable	true

role

The role block describes a database role or group.

role "analysts" {
  member_of = [role.readers]
  comment   = "Analytics team"
}

role attributes

Name	Required	Value
comment	false	string
conn_limit	false	int
create_db	false	bool
external	false	bool
group	false	bool
member_of	false	List of object reference to role
name	false	string
superuser	false	bool

role blocks

role.membership

The membership block describes a membership in a role, along with its options.

user "vault" {
  membership {
    role  = role.reader
    admin = true
  }
}

role.membership attributes

Name	Required	Value
admin	false	bool
role	true	Object reference to role

role.membership constraints

Constraint	Value
Required	false
Require Name	false
Repeatable	true

role constraints

Constraint	Value
Required	false
Require Name (e.g., role "name" )	true

schema

The schema block describes a database schema.

schema "public" {
  ...
}

schema attributes

Name	Required	Value
comment	false	string
name	false	string

schema blocks

schema.annotation

schema.annotation constraints

Constraint	Value
Required	false
Require Name	false
Allow unknown blocks	true
Allow unknown attributes	true

schema.external.data_catalog

schema.external.data_catalog attributes

Name	Required	Value
catalog_role	false	string
database	false	string
iam_role	false	string
region	false	string

schema.external.hive_metastore

schema.external.hive_metastore attributes

Name	Required	Value
database	false	string
iam_role	false	string
port	false	int
uri	false	string

schema.external.kafka

schema.external.kafka attributes

Name	Required	Value
authentication	false	Streaming authentication type can be one of: string enum (NONE, IAM, MTLS)
authentication_arn	false	string
iam_role	false	string
region	false	string
secret_arn	false	string
uri	false	string

schema.external.kinesis

schema.external.kinesis attributes

Name	Required	Value
iam_role	false	string
region	false	string

schema.external.msk

schema.external.msk attributes

Name	Required	Value
authentication	false	Streaming authentication type can be one of: string enum (NONE, IAM, MTLS)
authentication_arn	false	string
cluster_arn	false	string
iam_role	false	string
region	false	string
secret_arn	false	string
uri	false	string

schema.external.mysql

schema.external.mysql attributes

Name	Required	Value
database	false	string
iam_role	false	string
port	false	int
secret_arn	false	string
uri	false	string

schema.external.postgres

schema.external.postgres attributes

Name	Required	Value
database	false	string
iam_role	false	string
port	false	int
schema	false	string
secret_arn	false	string
uri	false	string

schema.external.redshift

schema.external.redshift attributes

Name	Required	Value
database	false	string
schema	false	string

schema constraints

Constraint	Value
Required	false
Require Name (e.g., schema "name" )	true

table

The table block describes a table in a database schema.

table "users" {
  schema = schema.public
  column "id" {
    type = int
  }
  ...
}

table attributes

Name	Required	Value
comment	false	string
schema	true	Object reference to schema

table blocks

table.annotation

table.annotation constraints

Constraint	Value
Required	false
Require Name	false
Allow unknown blocks	true
Allow unknown attributes	true

table.column

table.column attributes

Name	Required	Value
comment	false	string
default	false	Column default value can be one of: bool string number Raw expression defined with sql("expr")
encode	false	enum (RAW, AZ64, BYTEDICT, DELTA, DELTA32K, LZO, MOSTLY8, MOSTLY16, MOSTLY32, RUNLENGTH, TEXT255, TEXT32K, ZSTD)
null	false	bool
type	true	Column type can be one of: Schema type Raw expression defined with sql("expr")

table.column blocks

table.column.annotation

table.column.annotation constraints

Constraint	Value
Required	false
Require Name	false
Allow unknown blocks	true
Allow unknown attributes	true

table.column.identity

table.column.identity attributes

Name	Required	Value
generated	false	enum (ALWAYS, BY_DEFAULT)
seed	false	int
step	false	int

table.column constraints

Constraint	Value
Required	false
Require Name (e.g., table.column "name" )	true

table.distribution

table.distribution attributes

Name	Required	Value
column	false	Object reference
style	false	enum (EVEN, KEY, ALL, AUTO)

table.sort

table.sort attributes

Name	Required	Value
columns	false	List of object reference to column
style	false	enum (AUTO, COMPOUND, INTERLEAVED)

table constraints

Constraint	Value
Required	false
Require Name (e.g., table "name" )	true
Allow Qualifier (e.g., table "schema" "name" )	true

user

The user block describes a database user.

user "app_user" {
  password    = "<sensitive>"
  valid_until = "2025-12-31 23:59:59+00"
  member_of   = [role.analysts]
  params = {
    enable_case_sensitive_super_attribute = true
    statement_timeout                     = 60000
  }
}

user attributes

Name	Required	Value
comment	false	string
conn_limit	false	int
create_db	false	bool
external	false	bool
group	false	bool
member_of	false	List of object reference to role
name	false	string
params	false	map
password	false	string
superuser	false	bool
valid_until	false	string

user blocks

user.membership

The membership block describes a membership in a role, along with its options.

user "vault" {
  membership {
    role  = role.reader
    admin = true
  }
}

user.membership attributes

Name	Required	Value
admin	false	bool
role	true	Object reference to role

user.membership constraints

Constraint	Value
Required	false
Require Name	false
Repeatable	true

user constraints

Constraint	Value
Required	false
Require Name (e.g., user "name" )	true

view

The view block describes a view in a database schema.

view "clean_users" {
  schema = schema.public
  column "id" {
    type = int
  }
  ...
}

view attributes

Name	Required	Value
as	true	string
comment	false	string
depends_on	false	List of object references
schema	true	Object reference to schema

view blocks

view.annotation

view.annotation constraints

Constraint	Value
Required	false
Require Name	false
Allow unknown blocks	true
Allow unknown attributes	true

view.column

view.column attributes

Name	Required	Value
comment	false	string
null	false	bool
type	true	Column type can be one of: Schema type Raw expression defined with sql("expr")

view.column blocks

view.column.annotation

view.column.annotation constraints

Constraint	Value
Required	false
Require Name	false
Allow unknown blocks	true
Allow unknown attributes	true

view.column constraints

Constraint	Value
Required	false
Require Name (e.g., view.column "name" )	true

view constraints

Constraint	Value
Required	false
Require Name (e.g., view "name" )	true
Allow Qualifier (e.g., view "schema" "name" )	true