A variable length string

A fixed length string.

An unlimited length text column. Available lengths: tiny, medium, long

A 8 bit integer.

A 16 bit integer.

A 24 bit integer.

A 32 bit integer.

A 64 bit integer. Note: an attribute defined as BIGINT will be treated like a string due this feature from node-postgres to prevent precision loss. To have this attribute as a number, this is a possible workaround.

Floating point number (4-byte precision).

Floating point number (8-byte precision).

Decimal number.

Floating point number (4-byte precision).

A boolean / tinyint column, depending on dialect

Binary storage. Available lengths: tiny, medium, long

An enumeration. DataTypes.ENUM('value', 'another value').

A datetime column

A date only column (no timestamp)

A time column

A default value of the current timestamp

A column storing a unique universal identifier. Use with UUIDV1 or UUIDV4 for default values.

A default unique universal identifier generated following the UUID v1 standard

A default unique universal identifier generated following the UUID v4 standard

A key / value store column. Only available in Postgres.

A JSON string column. Available in MySQL, Postgres and SQLite

A binary storage JSON column. Only available in Postgres.

An array of type, e.g. DataTypes.ARRAY(DataTypes.DECIMAL). Only available in Postgres.

Range types are data types representing a range of values of some element type (called the range's subtype). Only available in Postgres. See the Postgres documentation for more details

A column storing Geometry information. It is only available in PostgreSQL (with PostGIS) or MySQL. In MySQL, allowable Geometry types are POINT, LINESTRING, POLYGON.

GeoJSON is accepted as input and returned as output. In PostGIS, the GeoJSON is parsed using the PostGIS function ST_GeomFromGeoJSON. In MySQL it is parsed using the function GeomFromText. Therefore, one can just follow the GeoJSON spec for handling geometry objects. See the following examples:

// Create a new point:
const point = { type: 'Point', coordinates: [39.807222,-76.984722]};

User.create({username: 'username', geometry: point });

// Create a new linestring:
const line = { type: 'LineString', 'coordinates': [ [100.0, 0.0], [101.0, 1.0] ] };

User.create({username: 'username', geometry: line });

// Create a new polygon:
const polygon = { type: 'Polygon', coordinates: [
                [ [100.0, 0.0], [101.0, 0.0], [101.0, 1.0],
                  [100.0, 1.0], [100.0, 0.0] ]
                ]};

User.create({username: 'username', geometry: polygon });

// Create a new point with a custom SRID:
const point = {
  type: 'Point',
  coordinates: [39.807222,-76.984722],
  crs: { type: 'name', properties: { name: 'EPSG:4326'} }
};

User.create({username: 'username', geometry: point })

A geography datatype represents two dimensional spacial objects in an elliptic coord system.

A virtual value that is not stored in the DB. This could for example be useful if you want to provide a default value in your model that is returned to the user but not stored in the DB.

You could also use it to validate a value before permuting and storing it. Checking password length before hashing it for example:

sequelize.define('user', {
  password_hash: DataTypes.STRING,
  password: {
    type: DataTypes.VIRTUAL,
    set: function (val) {
       // Remember to set the data value, otherwise it won't be validated
       this.setDataValue('password', val);
       this.setDataValue('password_hash', this.salt + val);
     },
     validate: {
        isLongEnough: function (val) {
          if (val.length < 7) {
            throw new Error("Please choose a longer password")
         }
      }
    }
  }
})

In the above code the password is stored plainly in the password field so it can be validated, but is never stored in the DB.

VIRTUAL also takes a return type and dependency fields as arguments If a virtual attribute is present in attributes it will automatically pull in the extra fields as well. Return type is mostly useful for setups that rely on types like GraphQL.

{
  active: {
    type: new DataTypes.VIRTUAL(DataTypes.BOOLEAN, ['createdAt']),
    get: function() {
      return this.get('createdAt') > Date.now() - (7 * 24 * 60 * 60 * 1000)
    }
  }
}

Defer constraints checks to the end of transactions.

Trigger the constraint checks immediately

Set the constraints to not deferred. This is the default in PostgreSQL and it make it impossible to dynamically defer the constraints within a transaction.