Powerful visual editor for Doctrine 2

Import, edit and export Doctrine 2 definitions just in a few clicks.

Speed up your work and avoid routine.

  • Entity
  • Bundle
  • Project
Skipper diagram - entity Skipper diagram - bundle Skipper diagram - project

1.Visually edit your project model.

  • Annotations
  • XML
  • YML
<?php
use Doctrine\ORM\Mapping AS ORM;

/**
 * @ORM\Entity
 * @ORM\Table(schema="ecommerce_order", options={"charset":"utf8","collate":"utf8_unicode_ci"})
 * @ORM\ChangeTrackingPolicy("DEFERRED_IMPLICIT")
 */
class EcommerceOrder
{
    /**
     * @ORM\Id
     * @ORM\Column(type="integer", length=4, options={"unsigned":true})
     * @ORM\GeneratedValue(strategy="SEQUENCE")
     */
    private $id;

    /**
     * @ORM\Column(type="datetime", nullable=true)
     */
    private $ordered_at;

    /**
     * @ORM\Column(type="string", nullable=true)
     */
    private $customer_note;

    /**
     * @ORM\Column(type="string", nullable=true)
     */
    private $internal_note;

    /**
     * @ORM\OneToOne(targetEntity="Address")
     * @ORM\JoinColumn(name="billing_address_id", referencedColumnName="id", unique=true)
     */
    private $BillingAddress;

    /**
     * @ORM\ManyToOne(targetEntity="Address")
     * @ORM\JoinColumn(name="delivery_address_id", referencedColumnName="id")
     */
    private $DeliveryAddress;
}
<?xml version="1.0"?>
<doctrine-mapping 
 xmlns="http://doctrine-project.org/schemas/orm/doctrine-mapping" 
 xsi="http://www.w3.org/2001/XMLSchema-instance" 
 schemaLocation="http://doctrine-project.org/schemas/orm/doctrine-mapping.xsd">
  <entity 
     name="EcommerceOrder" 
     change-tracking-policy="DEFERRED_IMPLICIT" 
     schema="ecommerce_order" 
     repository-class="Doctrine\ORM\EntityRepository">
    <id name="id" type="integer" length="4">
      <generator strategy="SEQUENCE"/>
      <options>
        <option name="unsigned" value="true"/>
      </options>
    </id>
    <field name="ordered_at" type="datetime" nullable="true"/>
    <field name="customer_note" type="string" nullable="true" version="true"/>
    <field name="internal_note" type="string" nullable="true" version="true"/>
    <many-to-one field="DeliveryAddress" target-entity="Address">
      <join-columns>
        <join-column 
                 name="delivery_address_id" 
                 referenced-column-name="id" 
                 on-delete="CASCADE"/>
      </join-columns>
    </many-to-one>
    <one-to-one field="BillingAddress" target-entity="Address">
      <join-columns>
        <join-column 
                 name="billing_address_id" 
                 referenced-column-name="id" 
                 unique="true" 
                 on-delete="CASCADE"/>
      </join-columns>
    </one-to-one>
    <options>
      <option name="charset" value="utf8"/>
      <option name="collate" value="utf8_unicode_ci"/>
    </options>
  </entity>
</doctrine-mapping>
EcommerceOrder:
  type: entity
  changeTrackingPolicy: DEFERRED_IMPLICIT
  schema: ecommerce_order
  repositoryClass: Doctrine\ORM\EntityRepository
  fields:
    id:
      id: true
      type: integer
      length: 4
      generator:
        strategy: SEQUENCE
      options:
        unsigned: true
    ordered_at:
      type: datetime
      nullable: true
    customer_note:
      type: string
      nullable: true
      version: true
    internal_note:
      type: string
      nullable: true
      version: true
  options:
    charset: utf8
    collate: utf8_unicode_ci
  oneToOne:
    BillingAddress:
      targetEntity: Address
      joinColumns:
        billing_address_id:
          referencedColumnName: id
          unique: true
          onDelete: CASCADE
  manyToOne:
    DeliveryAddress:
      targetEntity: Address
      joinColumns:
        delivery_address_id:
          referencedColumnName: id
          onDelete: CASCADE

2.Export it to complete definition files.

Download 14-day trial version

Try Skipper for free. No credit card needed.


Why use Skipper

Simple Project import

With sophisticated import wizard you can import your existing Doctrine 2 projects in just a few clicks. Created visual model allows you to discover complete project logic simply and quickly.

Skipper file menu Skipper Doctrine2 import wizard Skipper Doctrine2 import wizard - definition files Skipper imported Doctrine2 project

Definitions exported by one click

You can export your Doctrine 2 project repeatedly and as many times as you need. Exported definitions are in standardized and ready-to-use format without the need of further editing.

Skipper Doctrine2 export settings Skipper Doctrine2 export results Doctrine2 definitions exported by Skipper

Editing in visual interface

Intuitive wizards and dialogs guide you through editing of all objects. Each change in model is properly transferred to the definition files in the moment of their export.

Skipper entity editor for Doctrine2 Skipper bundle editor for Doctrine2 Skipper Association editor for Doctrine2

Lower need of Doctrine 2 skills

Thanks to Skipper inbuilt value advisors, validators, assistants and definitions created via standardized templates you can stop worrying about Doctrine 2 syntax and keywords.

Skipper Doctrine2 property editor - tracking policies, entity listener Skipper Doctrine2 property editor - lifecycle callback Skipper editing Doctrine2 fields

See all the features


Support for all Doctrine 2 features

Supported formats

All standard formats for Doctrine 2 are supported. You can import and export XML, YML (YAML) as well as PHP annotations.


Skipper Doctrine2 xml export result Skipper Doctrine2 yml export result Skipper Doctrine2 annotations export result

Entities and modules

Create entities, change their fields and ORM properties or simply remove them from the model. Use colors to create logical units and make orientation in the model easier.

Skipper diagram of Doctrine2 entities and associations Editing Doctrine2 fields, associations and inheritance in Skipper Skipper visual model of Doctrine2 project

Associations

With smart wizards you can create all types of Doctrine 2 associations. Use one to one, one to many and many to many associations and define owner and inverse entity or MN entity and aliases.

Skipper Doctrine2 Many-to-Many wizard Skipper Doctrine2 Association wizard Skipper Doctrine2 Many-to-Many editor Skipper Doctrine2 Association editor

Inheritance

Easy to understand dialog guides you through Doctrine 2 inheritance creation. In one place you can edit inheritance type, discriminators and base and derived entity.

Skipper Doctrine2 inheritance wizard Skipper Doctrine2 inheritance editor

Indexes

Create indexes and manage them with the help of intuitive Entity Editor. Specify all indexes you need and which fields are indexed by them.

Skipper Doctrine2 index editor

ORM Properties

Alter all model properties as needed. Skipper unique Property Editor provides quick and easy way to create, edit or delete any value.

Skipper Doctrine2 property editor - attributes and options Skipper Doctrine2 property editor - tracking policy Skipper Doctrine2 property editor - lifecycle callback

Customization

Implement your own customizations to Skipper so it maximally suits your needs. Create new behaviors, configure custom properties or datatypes or connect Skipper with external tools.

Support for MVC frameworks

With Skipper you can use Symfony, Zend or other MVC framework without any limitation. Skipper exports definitions with support for any MVC framework.

Over 1,000 companies use Skipper every day

It saved us a lot of time designing and configuring complex data models. It is impressive to see what this software achieves on its own.

Michael Stoye, ColorGATE

It simplifies our work because it saves us time. With features added over time like adding behaviors to Propel in Skipper it has become an unmissable tool in our organisation.

Erwin te Bos, aXtion

We have good use of the tool. It simplifies our daily work, saves us time and is simple and intuitive to use.

Thomas Somoen, Try/Apt

We use Skipper on our daily basis for ecommerce software development. It lets us visualize at a glance the data models and work on them in a simple and easy way.

Dario Schilman, IDS Soluciones Ecommerce

Skipper is a stable and easy to use schema designing tool! No documentation, just design and everything is documented!

Siebe Vos, Inform'aid

Simply put, for us, Skipper is not just a tool to master, but a mastermind that teaches us the best programming practices.

Can Berkol, Biber Ltd

Skipper is especially helpful in the initial data modeling phase. Exporting the data model and scaffolding makes it really easy to get a first prototype up and running in a matter of minutes.

Jörn Wagner, Explicatis

It is faster and gives less errors to have Skipper create the mapping code instead of writing it myself. Later in the development process I often use the Skipper diagram as a quick reference.

Herman Peeren, Yepr

More user stories

Detailed List of supported Doctrine 2 ORM properties

Skipper model properties

Object Property
Project name, storage path, description
Module name, description, external plugin storage, export path and format
Entity name, description
Field name, type, size, required, unique, primary key, auto increment, default value, enum values, description
Association owner/inverse entity, reference fields, owner/inverse alias, association type (one-to-one, one-to-many), parent requirement, description
Many to Many mn entity, owner/inverse entity, reference fields, owner/inverse alias, description
Inheritance base/derived entity, inheritance type, discriminator value/field, description
Index name, unique, indexed fields, description

Doctrine 2 model properties

Object Property
Project -
Module namespace, file-suffix (.dcm, .orm, without-siffix), filename-format (with-namespace, entity-only)
Entity table, schema, repository-class, export-file-name, change-tracking-policy (DEFERRED_IMPLICIT, DEFERRED_EXPLICIT, NOTIFY), lifecycle-callbacks(type, method)
Field column, version, scale, precision, column-definition, generator (strategy), sequence-generator (sequence-name, allocation-size, initial-value)
Association onDelete, onUpdate, orderBy, side-owning / side-inverse (fetch, orphan-removal, cascade, order-by)
Many to Many join-table-schema, fetch, on-delete, on-update, cascade, order-by
Inheritance -

Doctrine 2 datatypes support

  • string
  • integer
  • smallint
  • bigint
  • boolean
  • decimal
  • date
  • time
  • datetime
  • text
  • object
  • array

Doctrine 2 inheritance support

  • SINGLE_TABLE
  • JOINED
  • MAPPED_SUPERCLASS

Doctrine 2 model import / export formats

  • XML definitions
  • YAML (YML) definitions
  • PHP Annotations

Doctrine 2 associations support

  • Doctrine 2 One to one (one-to-one)
  • Doctrine 2 One to many (one-to-many)
  • Doctrine 2 Many to one (many-to-one)
  • Doctrine 2 Many to many (many-to-many)