Add a CREATE TABLE statement to this migration

The first argument is the name of the table.

The second argument is a table containing a FieldSchema for each field. See documentation on the Field command for more information.

Add a DROP TABLE statement to this migration.

Copy a table schema from one database to another

Monad representing a series of ALTER TABLE statements

A column in the process of being altered

Compose a series of ALTER TABLE commands

Example usage

migrate (OldDb oldTbl) = do
  alterTable oldTbl $ oldTbl' ->
    field2 <- renameColumnTo NewNameForField2 (_field2 oldTbl')
    dropColumn (_field3 oldTbl')
    renameTableTo NewTableName
    field4 <- addColumn (field ANewColumn smallint notNull (defaultTo_ (val_ 0)))
    return (NewTable (_field1 oldTbl') field2 field4)

The above would result in commands like:

ALTER TABLE oldtable RENAME COLUMN field2 TO NewNameForField2;
ALTER TABLE oldtable DROP COLUMN field3;
ALTER TABLE oldtable RENAME TO NewTableName;
ALTER TABLE NewTableName ADD COLUMN ANewColumn SMALLINT NOT NULL DEFAULT 0;

ALTER TABLE ... RENAME TO command

ALTER TABLE ... RENAME COLUMN ... TO ... command

ALTER TABLE ... ADD COLUMN ... command

ALTER TABLE ... DROP COLUMN ... command

Represents the default value of a field with a given column schema syntax and type

Represents a constraint in the given column schema syntax

Build a schema for a field. This function takes the name and type of the field and a variable number of modifiers, such as constraints and default values. GHC will complain at you if the modifiers do not make sense. For example, you cannot apply the notNull constraint to a column with a Maybe type.

Example of creating a table named Employee with three columns: FirstName, LastName, and HireDate

data Employee f =
  Employee { _firstName :: C f Text
           , _lastName  :: C f Text
           , _hireDate  :: C f (Maybe LocalTime)
           } deriving Generic
instance Beamable Employee

instance Table Employee where
   data PrimaryKey Employee f = EmployeeKey (C f Text) (C f Text) deriving Generic
   primaryKey = EmployeeKey $ _firstName * _lastName

instance Beamable PrimaryKey Employee f

data EmployeeDb entity
    = EmployeeDb { _employees :: entity (TableEntity Employee) }
    deriving Generic
instance Database EmployeeDb

migration :: IsSql92DdlCommandSyntax syntax => Migration syntax () EmployeeDb
migration = do
  employees <- createTable EmployeesTable
                 (Employee (field FirstNameField (varchar (Just 15)) notNull)
                           (field "last_name" (varchar Nothing) notNull (defaultTo_ (val_ Smith)))
                           (field "hiredDate" (maybeType timestamp)))
  return (EmployeeDb employees)

Build a DefaultValue from a QExpr. GHC will complain if you supply more than one default value.

The SQL92 NOT NULL constraint

SQL UNIQUE constraint

SQL92 INTEGER data type

SQL92 SMALLINT data type

SQL2008 Optional BIGINT data type

SQL92 CHAR data type

SQL92 VARCHAR data type

SQL92 DOUBLE data type

SQL99 CLOB data type

SQL99 BLOB data type

SQL99 array data types

SQL99 BOOLEAN data type

SQL92 NUMERIC data type

SQL92 DATE data type

SQL92 TIME data type

SQL92 TIMESTAMP WITHOUT TIME ZONE data type

SQL92 TIMESTAMP WITH TIME ZONE data type

SQL2003 Optional BINARY data type

SQL2003 Optional VARBINARY data type

Haskell requires DataTypes to match exactly. Use this function to convert a DataType that expects a concrete value to one expecting a Maybe