Create Column

Add new columns to existing tables with full control over data types, constraints, and properties.

create()

Create a single column in an existing table.

client.columns.create(tableName: string, column: FieldDefinition): Promise<BolticSuccessResponse<ColumnRecord> | BolticErrorResponse>

Parameters

Parameter	Type	Required	Description
tableName	string	✅	Name of the target table
column	FieldDefinition	✅	Column definition object

FieldDefinition Properties

Property	Type	Required	Description
name	string	✅	Column name (alphanumeric + underscore)
type	FieldType	✅	Column data type
description	string	❌	Human-readable description
is_nullable	boolean	❌	Allow null values (default: true)
is_unique	boolean	❌	Enforce unique values (default: false)
is_indexed	boolean	❌	Create database index (default: false)
default_value	any	❌	Default value for new records

Examples

Basic Text Column

const { data, error } = await client.columns.create("products", {
    name: "title",
    type: "text",
    is_nullable: false,
    is_indexed: true,
    description: "Product title",
});

if (!error) {
    console.log("Column created:", data.name);
}

Currency Column

const { data, error } = await client.columns.create("products", {
    name: "price",
    type: "currency",
    currency_format: "USD",
    decimals: "0.00",
    is_nullable: false,
    default_value: 0.0,
    description: "Product price in USD",
});

Dropdown Column

const { data, error } = await client.columns.create("products", {
    name: "category",
    type: "dropdown",
    selectable_items: ["Electronics", "Clothing", "Books", "Home & Garden"],
    multiple_selections: false,
    is_nullable: false,
    description: "Product category",
});

Date-Time Column

const { data, error } = await client.columns.create("events", {
    name: "event_date",
    type: "date-time",
    date_format: "%d/%m/%Y",
    time_format: "HH:mm:ss",
    is_nullable: true,
    description: "Event start date and time",
});

Vector Column for AI/ML

const { data, error } = await client.columns.create("documents", {
    name: "embeddings",
    type: "vector",
    vector_dimension: 1536,
    is_indexed: true,
    description: "Document embeddings for similarity search",
});

Encrypted Column (Non-Deterministic)

const { data, error } = await client.columns.create("users", {
    name: "api_key",
    type: "encrypted",
    is_deterministic: false, // Default - highest security
    show_decrypted: false, // Default - values masked as ********
    is_nullable: false,
    description: "User API key with non-deterministic encryption",
});

Encrypted Column (Deterministic - Searchable)

const { data, error } = await client.columns.create("customers", {
    name: "ssn",
    type: "encrypted",
    is_deterministic: true, // Enables filtering and searching
    show_decrypted: false,
    is_indexed: true, // Can be indexed for performance
    is_nullable: false,
    description: "Social Security Number (searchable encrypted)",
});

Response Format

{
  data: {
    id: "26b364ef-0401-49b2-aae3-ebe43ae14eca",
  },
   "message": "Column embeddings added successfully"
}

createMany()

Create multiple columns in a single operation for better performance.

client.columns.createMany(tableName: string, columns: FieldDefinition[]): Promise<BolticListResponse<ColumnRecord> | BolticErrorResponse>

Parameters

Parameter	Type	Required	Description
tableName	string	✅	Name of the target table
columns	FieldDefinition[]	✅	Array of column definitions

Example: User Profile Schema

const userColumns = [
    {
        name: "first_name",
        type: "text",
        is_nullable: false,
        description: "User first name",
    },
    {
        name: "last_name",
        type: "text",
        is_nullable: false,
        description: "User last name",
    },
    {
        name: "email",
        type: "email",
        is_unique: true,
        is_nullable: false,
        is_indexed: true,
        description: "User email address",
    },
    {
        name: "phone",
        type: "phone-number",
        phone_format: "+1 (123) 456-7890",
        is_nullable: true,
        description: "User phone number",
    },
    {
        name: "age",
        type: "number",
        decimals: "0",
        is_nullable: true,
        description: "User age",
    },
    {
        name: "is_verified",
        type: "checkbox",
        default_value: false,
        description: "Whether user is verified",
    },
    {
        name: "profile_data",
        type: "json",
        is_nullable: true,
        description: "Additional profile information",
    },
];

const { data, error } = await client.columns.createMany("users", userColumns);

if (!error) {
    console.log(`Created ${data.length} columns successfully`);
    data.forEach((column) => {
        console.log(`- ${column.name} (${column.type})`);
    });
}

Example: E-commerce Product Schema

const productColumns = [
    {
        name: "title",
        type: "text",
        is_nullable: false,
        is_unique: true,
        is_indexed: true,
        description: "Product title",
    },
    {
        name: "description",
        type: "long-text",
        is_nullable: true,
        description: "Product description",
    },
    {
        name: "price",
        type: "currency",
        currency_format: "USD",
        decimals: "0.00",
        is_nullable: false,
        is_indexed: true,
        description: "Product price",
    },
    {
        name: "sale_price",
        type: "currency",
        currency_format: "USD",
        decimals: "0.00",
        is_nullable: true,
        description: "Sale price if on discount",
    },
    {
        name: "sku",
        type: "text",
        is_unique: true,
        is_nullable: false,
        is_indexed: true,
        description: "Stock keeping unit",
    },
    {
        name: "category",
        type: "dropdown",
        selection_source: "provide-static-list",
        selectable_items: ["Electronics", "Clothing", "Books", "Home & Garden"],
        multiple_selections: false,
        is_nullable: false,
        description: "Product category",
    },
    {
        name: "tags",
        type: "dropdown",
        selection_source: "provide-static-list",
        selectable_items: ["new", "bestseller", "sale", "limited"],
        multiple_selections: true,
        is_nullable: true,
        description: "Product tags",
    },
    {
        name: "is_active",
        type: "checkbox",
        default_value: true,
        description: "Whether product is active",
    },
    {
        name: "launch_date",
        type: "date-time",
        timezone: "UTC",
        date_format: "MM/DD/YYYY",
        is_nullable: true,
        description: "Product launch date",
    },
    {
        name: "specifications",
        type: "json",
        is_nullable: true,
        description: "Product specifications and features",
    },
];

const { data, error } = await client.columns.createMany("products", productColumns);

Type-Specific Properties

Different field types require additional properties:

Currency Fields

{
  name: 'price',
  type: 'currency',
  currency_format: 'USD', // Required: ISO currency code
  decimals: '0.00',       // Optional: decimal precision
}

Phone Number Fields

{
  name: 'phone',
  type: 'phone-number',
  phone_format: '+1 (123) 456-7890' // Required: display format
}

Dropdown Fields

{
  name: 'status',
  type: 'dropdown',
  selectable_items: ['active', 'inactive'], // Required
  multiple_selections: false                // Required
}

Date-Time Fields

{
  name: 'created_date',
  type: 'date-time',
  date_format: 'MM/DD/YYYY',         // Optional
  time_format: 'HH:mm:ss'            // Optional
}

Vector Fields

{
  name: 'embeddings',
  type: 'vector',
  vector_dimension: 1536 // Required: dimension size
}

Encrypted Fields

{
  name: 'api_secret',
  type: 'encrypted',
  is_deterministic: false,  // Optional: enables filtering (default: false)
  show_decrypted: false     // Optional: show decrypted in UI (default: false)
}

Encrypted Column Constraints

• Cannot have default_value - Will throw validation error
• Cannot be is_unique - Uniqueness constraint not supported
• is_deterministic is immutable - Cannot be changed after creation
• Only deterministic encrypted columns can be used in filters

For SQL encryption/decryption functions (BOLTIC_ENCRYPT, BOLTIC_DECRYPT), see the Tables Column Documentation.

Validation Rules

Column Names

• Must contain only letters, numbers, and underscores
• Cannot start with a number
• Cannot be a reserved keyword (id, created_at, updated_at)
• Maximum length: 63 characters

Non-Nullable Columns

info

Cannot create columns with is_nullable: false on tables that already contain rows

To add a non-nullable column to a table with existing data, you must first delete all rows from the table.

Best Practices

Column Design

• Use descriptive names that clearly indicate the column's purpose
• Set appropriate constraints (is_nullable, is_unique, is_indexed)
• Choose the most specific data type for your use case
• Consider performance impact of indexing

Default Values

• Use null as default for optional fields
• Ensure default values match the column type

Bulk Creation

• Use createMany() for multiple columns to improve performance
• Group related columns together logically
• Validate all column definitions before bulk creation

Related

• Column Properties Reference - Complete property values and validation rules