TheCodingMachine\TDBM\Utils\BeanDescriptor

Complexity

Total Complexity

141

Size/Duplication

Total Lines	1369
Duplicated Lines	0 %

Importance

Changes

0

34 Methods

Rating	Name	Duplication	Size	Complexity
A	getMethodDescriptors()	0	23	5
F	generateFindByDaoCodeForIndex()	0	138	18
A	generateJsonSerialize()	0	36	4
A	getGeneratedBeanNamespace()	0	3	1
A	getBeanPropertyDescriptors()	0	3	1
A	getPivotTableDescriptors()	0	19	4
A	psr2VarExport()	0	13	4
A	removeDuplicateIndexes()	0	8	2
A	getBaseDaoClassName()	0	3	1
F	generatePhpCode()	0	121	17
A	generateGetUsedTablesCode()	0	19	2
A	generateExtendsAndUseStatements()	0	22	5
A	getPropertiesWithDefault()	0	8	1
A	generateGetForeignKeys()	0	43	3
A	getBeanClassName()	0	3	1
A	getDaoClassName()	0	3	1
A	getDefaultSortColumnFromAnnotation()	0	18	5
A	getExtendedBeanClassName()	0	7	2
D	getPropertiesForTable()	0	66	14
A	getExposedProperties()	0	7	1
A	initBeanPropertyDescriptors()	0	3	1
A	generateCloneCode()	0	13	2
A	isPartOfForeignKey()	0	12	4
A	getTable()	0	3	1
A	generateBeanConstructor()	0	37	5
A	getBaseBeanClassName()	0	3	1
A	generateOnDeleteCode()	0	22	4
F	generateDaoPhpCode()	0	366	17
A	getConstructorProperties()	0	7	1
A	generateFindByDaoCode()	0	17	5
A	__construct()	0	15	1
A	getProperties()	0	23	4
A	getBeanNamespace()	0	3	1
A	getDirectForeignKeysDescriptors()	0	11	2

<?php
declare(strict_types=1);

namespace TheCodingMachine\TDBM\Utils;

use Doctrine\DBAL\Schema\Column;
use Doctrine\DBAL\Schema\Index;
use Doctrine\DBAL\Schema\Schema;
use Doctrine\DBAL\Schema\Table;
use Doctrine\DBAL\Schema\ForeignKeyConstraint;
use JsonSerializable;
use Mouf\Database\SchemaAnalyzer\SchemaAnalyzer;
use PhpParser\Comment\Doc;
use Ramsey\Uuid\Uuid;
use TheCodingMachine\TDBM\AbstractTDBMObject;
use TheCodingMachine\TDBM\AlterableResultIterator;
use TheCodingMachine\TDBM\ConfigurationInterface;
use TheCodingMachine\TDBM\ResultIterator;
use TheCodingMachine\TDBM\SafeFunctions;
use TheCodingMachine\TDBM\Schema\ForeignKey;
use TheCodingMachine\TDBM\Schema\ForeignKeys;
use TheCodingMachine\TDBM\TDBMException;
use TheCodingMachine\TDBM\TDBMSchemaAnalyzer;
use TheCodingMachine\TDBM\TDBMService;
use TheCodingMachine\TDBM\Utils\Annotation\AnnotationParser;
use Zend\Code\Generator\AbstractMemberGenerator;
use Zend\Code\Generator\ClassGenerator;
use Zend\Code\Generator\DocBlock\Tag\ParamTag;
use Zend\Code\Generator\DocBlock\Tag\ReturnTag;
use Zend\Code\Generator\DocBlock\Tag\ThrowsTag;
use Zend\Code\Generator\DocBlock\Tag\VarTag;
use Zend\Code\Generator\DocBlockGenerator;
use Zend\Code\Generator\FileGenerator;
use Zend\Code\Generator\MethodGenerator;
use Zend\Code\Generator\ParameterGenerator;
use Zend\Code\Generator\PropertyGenerator;

/**
 * This class represents a bean.
 */
class BeanDescriptor implements BeanDescriptorInterface
{
    /**
     * @var Table
     */
    private $table;

    /**
     * @var SchemaAnalyzer
     */
    private $schemaAnalyzer;

    /**
     * @var Schema
     */
    private $schema;

    /**
     * @var AbstractBeanPropertyDescriptor[]
     */
    private $beanPropertyDescriptors = [];

    /**
     * @var TDBMSchemaAnalyzer
     */
    private $tdbmSchemaAnalyzer;

    /**
     * @var NamingStrategyInterface
     */
    private $namingStrategy;
    /**
     * @var string
     */
    private $beanNamespace;
    /**
     * @var string
     */
    private $generatedBeanNamespace;
    /**
     * @var AnnotationParser
     */
    private $annotationParser;
    /**
     * @var string
     */
    private $daoNamespace;
    /**
     * @var string
     */
    private $generatedDaoNamespace;
    /**
     * @var CodeGeneratorListenerInterface
     */
    private $codeGeneratorListener;
    /**
     * @var ConfigurationInterface
     */
    private $configuration;

    public function __construct(Table $table, string $beanNamespace, string $generatedBeanNamespace, string $daoNamespace, string $generatedDaoNamespace, SchemaAnalyzer $schemaAnalyzer, Schema $schema, TDBMSchemaAnalyzer $tdbmSchemaAnalyzer, NamingStrategyInterface $namingStrategy, AnnotationParser $annotationParser, CodeGeneratorListenerInterface $codeGeneratorListener, ConfigurationInterface $configuration)
    {
        $this->table = $table;
        $this->beanNamespace = $beanNamespace;
        $this->generatedBeanNamespace = $generatedBeanNamespace;
        $this->daoNamespace = $daoNamespace;
        $this->generatedDaoNamespace = $generatedDaoNamespace;
        $this->schemaAnalyzer = $schemaAnalyzer;
        $this->schema = $schema;
        $this->tdbmSchemaAnalyzer = $tdbmSchemaAnalyzer;
        $this->namingStrategy = $namingStrategy;
        $this->annotationParser = $annotationParser;
        $this->codeGeneratorListener = $codeGeneratorListener;
        $this->configuration = $configuration;
        $this->initBeanPropertyDescriptors();
    }

    private function initBeanPropertyDescriptors(): void
    {
        $this->beanPropertyDescriptors = $this->getProperties($this->table);
    }

    /**
     * Returns the foreign-key the column is part of, if any. null otherwise.
     *
     * @param Table  $table
     * @param Column $column
     *
     * @return ForeignKeyConstraint|null
     */
    private function isPartOfForeignKey(Table $table, Column $column) : ?ForeignKeyConstraint
    {
        $localColumnName = $column->getName();
        foreach ($table->getForeignKeys() as $foreignKey) {
            foreach ($foreignKey->getUnquotedLocalColumns() as $columnName) {
                if ($columnName === $localColumnName) {
                    return $foreignKey;
                }
            }
        }

        return null;
    }

    /**
     * @return AbstractBeanPropertyDescriptor[]
     */
    public function getBeanPropertyDescriptors(): array
    {
        return $this->beanPropertyDescriptors;
    }

    /**
     * Returns the list of columns that are not nullable and not autogenerated for a given table and its parent.
     *
     * @return AbstractBeanPropertyDescriptor[]
     */
    public function getConstructorProperties(): array
    {
        $constructorProperties = array_filter($this->beanPropertyDescriptors, function (AbstractBeanPropertyDescriptor $property) {
            return $property->isCompulsory();
        });

        return $constructorProperties;
    }

    /**
     * Returns the list of columns that have default values for a given table.
     *
     * @return AbstractBeanPropertyDescriptor[]
     */
    public function getPropertiesWithDefault(): array
    {
        $properties = $this->getPropertiesForTable($this->table);
        $defaultProperties = array_filter($properties, function (AbstractBeanPropertyDescriptor $property) {
            return $property->hasDefault();
        });

        return $defaultProperties;
    }

    /**
     * Returns the list of properties exposed as getters and setters in this class.
     *
     * @return AbstractBeanPropertyDescriptor[]
     */
    public function getExposedProperties(): array
    {
        $exposedProperties = array_filter($this->beanPropertyDescriptors, function (AbstractBeanPropertyDescriptor $property) {
            return $property->getTable()->getName() == $this->table->getName();
        });

        return $exposedProperties;
    }

    /**
     * Returns the list of properties for this table (including parent tables).
     *
     * @param Table $table
     *
     * @return AbstractBeanPropertyDescriptor[]
     */
    private function getProperties(Table $table): array
    {
        // Security check: a table MUST have a primary key
        TDBMDaoGenerator::getPrimaryKeyColumnsOrFail($table);

        $parentRelationship = $this->schemaAnalyzer->getParentRelationship($table->getName());
        if ($parentRelationship) {
            $parentTable = $this->schema->getTable($parentRelationship->getForeignTableName());
            $properties = $this->getProperties($parentTable);
            // we merge properties by overriding property names.
            $localProperties = $this->getPropertiesForTable($table);
            foreach ($localProperties as $name => $property) {
                // We do not override properties if this is a primary key!
                if ($property->isPrimaryKey()) {
                    continue;
                }
                $properties[$name] = $property;
            }
        } else {
            $properties = $this->getPropertiesForTable($table);
        }

        return $properties;
    }

    /**
     * Returns the list of properties for this table (ignoring parent tables).
     *
     * @param Table $table
     *
     * @return AbstractBeanPropertyDescriptor[]
     */
    private function getPropertiesForTable(Table $table): array
    {
        $parentRelationship = $this->schemaAnalyzer->getParentRelationship($table->getName());
        if ($parentRelationship) {
            $ignoreColumns = $parentRelationship->getUnquotedLocalColumns();
        } else {
            $ignoreColumns = [];
        }

        $beanPropertyDescriptors = [];
        foreach ($table->getColumns() as $column) {
            if (array_search($column->getName(), $ignoreColumns) !== false) {
                continue;
            }

            $fk = $this->isPartOfForeignKey($table, $column);
            if ($fk !== null) {
                // Check that previously added descriptors are not added on same FK (can happen with multi key FK).
                foreach ($beanPropertyDescriptors as $beanDescriptor) {
                    if ($beanDescriptor instanceof ObjectBeanPropertyDescriptor && $beanDescriptor->getForeignKey() === $fk) {
                        continue 2;
                    }
                }
                // Check that this property is not an inheritance relationship
                $parentRelationship = $this->schemaAnalyzer->getParentRelationship($table->getName());
                if ($parentRelationship === $fk) {
                    continue;
                }

                $beanPropertyDescriptors[] = new ObjectBeanPropertyDescriptor($table, $fk, $this->namingStrategy, $this->beanNamespace, $this->annotationParser);
            } else {
                $beanPropertyDescriptors[] = new ScalarBeanPropertyDescriptor($table, $column, $this->namingStrategy, $this->annotationParser);
            }
        }

        // Now, let's get the name of all properties and let's check there is no duplicate.
        /* @var $names AbstractBeanPropertyDescriptor[] */
        $names = [];
        foreach ($beanPropertyDescriptors as $beanDescriptor) {
            $name = $beanDescriptor->getGetterName();
            if (isset($names[$name])) {
                $names[$name]->useAlternativeName();
                $beanDescriptor->useAlternativeName();
            } else {
                $names[$name] = $beanDescriptor;
            }
        }

        // Final check (throw exceptions if problem arises)
        $names = [];
        foreach ($beanPropertyDescriptors as $beanDescriptor) {
            $name = $beanDescriptor->getGetterName();
            if (isset($names[$name])) {
                throw new TDBMException('Unsolvable name conflict while generating method name');
            } else {
                $names[$name] = $beanDescriptor;
            }
        }

        // Last step, let's rebuild the list with a map:
        $beanPropertyDescriptorsMap = [];
        foreach ($beanPropertyDescriptors as $beanDescriptor) {
            $beanPropertyDescriptorsMap[$beanDescriptor->getVariableName()] = $beanDescriptor;
        }

        return $beanPropertyDescriptorsMap;
    }

    private function generateBeanConstructor() : MethodGenerator
    {
        $constructorProperties = $this->getConstructorProperties();

        $constructor = new MethodGenerator('__construct', [], MethodGenerator::FLAG_PUBLIC);
        $constructor->setDocBlock('The constructor takes all compulsory arguments.');

        $assigns = [];
        $parentConstructorArguments = [];

        foreach ($constructorProperties as $property) {
            $parameter = new ParameterGenerator(ltrim($property->getVariableName(), '$'));
            if ($property->isTypeHintable()) {
                $parameter->setType($property->getPhpType());
            }
            $constructor->setParameter($parameter);

            $constructor->getDocBlock()->setTag($property->getParamAnnotation());

            if ($property->getTable()->getName() === $this->table->getName()) {
                $assigns[] = $property->getConstructorAssignCode()."\n";
            } else {
                $parentConstructorArguments[] = $property->getVariableName();
            }
        }

        $parentConstructorCode = sprintf("parent::__construct(%s);\n", implode(', ', $parentConstructorArguments));

        foreach ($this->getPropertiesWithDefault() as $property) {
            $assigns[] = $property->assignToDefaultCode()."\n";
        }

        $body = $parentConstructorCode . implode('', $assigns);

        $constructor->setBody($body);

        return $constructor;
    }

    /**
     * Returns the descriptors of one-to-many relationships (the foreign keys pointing on this beans)
     *
     * @return DirectForeignKeyMethodDescriptor[]
     */
    private function getDirectForeignKeysDescriptors(): array
    {
        $fks = $this->tdbmSchemaAnalyzer->getIncomingForeignKeys($this->table->getName());

        $descriptors = [];

        foreach ($fks as $fk) {
            $descriptors[] = new DirectForeignKeyMethodDescriptor($fk, $this->table, $this->namingStrategy, $this->annotationParser);
        }

        return $descriptors;
    }

    /**
     * @return PivotTableMethodsDescriptor[]
     */
    private function getPivotTableDescriptors(): array
    {
        $descs = [];
        foreach ($this->schemaAnalyzer->detectJunctionTables(true) as $table) {
            // There are exactly 2 FKs since this is a pivot table.
            $fks = array_values($table->getForeignKeys());

            if ($fks[0]->getForeignTableName() === $this->table->getName()) {
                list($localFk, $remoteFk) = $fks;
            } elseif ($fks[1]->getForeignTableName() === $this->table->getName()) {
                list($remoteFk, $localFk) = $fks;
            } else {
                continue;
            }

            $descs[] = new PivotTableMethodsDescriptor($table, $localFk, $remoteFk, $this->namingStrategy, $this->beanNamespace);
        }

        return $descs;
    }

    /**
     * Returns the list of method descriptors (and applies the alternative name if needed).
     *
     * @return MethodDescriptorInterface[]
     */
    public function getMethodDescriptors(): array
    {
        $directForeignKeyDescriptors = $this->getDirectForeignKeysDescriptors();
        $pivotTableDescriptors = $this->getPivotTableDescriptors();

        $descriptors = array_merge($directForeignKeyDescriptors, $pivotTableDescriptors);

        // Descriptors by method names
        $descriptorsByMethodName = [];

        foreach ($descriptors as $descriptor) {
            $descriptorsByMethodName[$descriptor->getName()][] = $descriptor;
        }

        foreach ($descriptorsByMethodName as $descriptorsForMethodName) {
            if (count($descriptorsForMethodName) > 1) {
                foreach ($descriptorsForMethodName as $descriptor) {
                    $descriptor->useAlternativeName();
                }
            }
        }

        return $descriptors;
    }

    public function generateJsonSerialize(): MethodGenerator
    {
        $tableName = $this->table->getName();
        $parentFk = $this->schemaAnalyzer->getParentRelationship($tableName);
        if ($parentFk !== null) {
            $initializer = '$array = parent::jsonSerialize($stopRecursion);';
        } else {
            $initializer = '$array = [];';
        }

        $method = new MethodGenerator('jsonSerialize');
        $method->setDocBlock('Serializes the object for JSON encoding.');
        $method->getDocBlock()->setTag(new ParamTag('$stopRecursion', ['bool'], 'Parameter used internally by TDBM to stop embedded objects from embedding other objects.'));
        $method->getDocBlock()->setTag(new ReturnTag(['array']));
        $method->setParameter(new ParameterGenerator('stopRecursion', 'bool', false));

        $str = '%s
%s
%s
return $array;
';

        $propertiesCode = '';
        foreach ($this->getExposedProperties() as $beanPropertyDescriptor) {
            $propertiesCode .= $beanPropertyDescriptor->getJsonSerializeCode();
        }

        // Many2many relationships
        $methodsCode = '';
        foreach ($this->getMethodDescriptors() as $methodDescriptor) {
            $methodsCode .= $methodDescriptor->getJsonSerializeCode();
        }

        $method->setBody(sprintf($str, $initializer, $propertiesCode, $methodsCode));

        return $method;
    }

    /**
     * Returns as an array the class we need to extend from and the list of use statements.
     *
     * @param ForeignKeyConstraint|null $parentFk
     * @return string[]
     */
    private function generateExtendsAndUseStatements(ForeignKeyConstraint $parentFk = null): array
    {
        $classes = [];
        if ($parentFk !== null) {
            $extends = $this->namingStrategy->getBeanClassName($parentFk->getForeignTableName());
            $classes[] = $extends;
        }

        foreach ($this->getBeanPropertyDescriptors() as $beanPropertyDescriptor) {
            $className = $beanPropertyDescriptor->getClassName();
            if (null !== $className) {
                $classes[] = $className;
            }
        }

        foreach ($this->getMethodDescriptors() as $descriptor) {
            $classes = array_merge($classes, $descriptor->getUsedClasses());
        }

        $classes = array_unique($classes);

        return $classes;
    }

    /**
     * Returns the representation of the PHP bean file with all getters and setters.
     *
     * @return ?FileGenerator
     */
    public function generatePhpCode(): ?FileGenerator
    {

        $file = new FileGenerator();
        $class = new ClassGenerator();
        $file->setClass($class);
        $file->setNamespace($this->generatedBeanNamespace);

        $tableName = $this->table->getName();
        $baseClassName = $this->namingStrategy->getBaseBeanClassName($tableName);
        $className = $this->namingStrategy->getBeanClassName($tableName);
        $parentFk = $this->schemaAnalyzer->getParentRelationship($this->table->getName());

        $classes = $this->generateExtendsAndUseStatements($parentFk);

        foreach ($classes as $useClass) {
            $file->setUse($this->beanNamespace.'\\'.$useClass);
        }

        /*$uses = array_map(function ($className) {
            return 'use '.$this->beanNamespace.'\\'.$className.";\n";
        }, $classes);
        $use = implode('', $uses);*/

        $extends = $this->getExtendedBeanClassName();
        if ($extends === null) {
            $class->setExtendedClass(AbstractTDBMObject::class);
            $file->setUse(AbstractTDBMObject::class);
        } else {
            $class->setExtendedClass($extends);
        }

        $file->setUse(ResultIterator::class);
        $file->setUse(AlterableResultIterator::class);
        $file->setUse(Uuid::class);
        $file->setUse(JsonSerializable::class);
        $file->setUse(ForeignKeys::class);

        $class->setName($baseClassName);
        $class->setAbstract(true);

        $file->setDocBlock(new DocBlockGenerator('This file has been automatically generated by TDBM.', <<<EOF
DO NOT edit this file, as it might be overwritten.
If you need to perform changes, edit the $className class instead!
EOF
        ));

        $class->setDocBlock(new DocBlockGenerator("The $baseClassName class maps the '$tableName' table in database."));
        $class->setImplementedInterfaces([ JsonSerializable::class ]);


        $method = $this->generateBeanConstructor();
        $method = $this->codeGeneratorListener->onBaseBeanConstructorGenerated($method, $this, $this->configuration, $class);
        if ($method) {
            $class->addMethodFromGenerator($this->generateBeanConstructor());
        }

        $fks = [];
        foreach ($this->getExposedProperties() as $property) {
            if ($property instanceof ObjectBeanPropertyDescriptor) {
                $fks[] = $property->getForeignKey();
            }
            [$getter, $setter] = $property->getGetterSetterCode();
            [$getter, $setter] = $this->codeGeneratorListener->onBaseBeanPropertyGenerated($getter, $setter, $property, $this, $this->configuration, $class);
            if ($getter !== null) {
                $class->addMethodFromGenerator($getter);
            }
            if ($setter !== null) {
                $class->addMethodFromGenerator($setter);
            }
        }

        foreach ($this->getMethodDescriptors() as $methodDescriptor) {
            if ($methodDescriptor instanceof DirectForeignKeyMethodDescriptor) {
                [$method] = $methodDescriptor->getCode();
                $method = $this->codeGeneratorListener->onBaseBeanOneToManyGenerated($method, $methodDescriptor, $this, $this->configuration, $class);
                if ($method) {
                    $class->addMethodFromGenerator($method);
                }
            } elseif ($methodDescriptor instanceof PivotTableMethodsDescriptor) {
                [ $getter, $adder, $remover, $has, $setter ] = $methodDescriptor->getCode();
                $methods = $this->codeGeneratorListener->onBaseBeanManyToManyGenerated($getter, $adder, $remover, $has, $setter, $methodDescriptor, $this, $this->configuration, $class);
                foreach ($methods as $method) {
                    if ($method) {
                        $class->addMethodFromGenerator($method);
                    }
                }
            } else {
                throw new \RuntimeException('Unexpected instance'); // @codeCoverageIgnore
            }
        }

        $foreignKeysProperty = new PropertyGenerator('foreignKeys');
        $foreignKeysProperty->setStatic(true);
        $foreignKeysProperty->setVisibility(AbstractMemberGenerator::VISIBILITY_PRIVATE);
        $foreignKeysProperty->setDocBlock(new DocBlockGenerator(null, null, [new VarTag(null, ['\\'.ForeignKeys::class])]));
        $class->addPropertyFromGenerator($foreignKeysProperty);

        $method = $this->generateGetForeignKeys($fks);
        $class->addMethodFromGenerator($method);

        $method = $this->generateJsonSerialize();
        $method = $this->codeGeneratorListener->onBaseBeanJsonSerializeGenerated($method, $this, $this->configuration, $class);
        if ($method !== null) {
            $class->addMethodFromGenerator($method);
        }

        $class->addMethodFromGenerator($this->generateGetUsedTablesCode());
        $onDeleteCode = $this->generateOnDeleteCode();
        if ($onDeleteCode) {
            $class->addMethodFromGenerator($onDeleteCode);
        }
        $cloneCode = $this->generateCloneCode();
        $cloneCode = $this->codeGeneratorListener->onBaseBeanCloneGenerated($cloneCode, $this, $this->configuration, $class);
        if ($cloneCode) {
            $class->addMethodFromGenerator($cloneCode);
        }

        $file = $this->codeGeneratorListener->onBaseBeanGenerated($file, $this, $this->configuration);

        return $file;
    }

    /**
     * Writes the representation of the PHP DAO file.
     *
     * @return ?FileGenerator
     */
    public function generateDaoPhpCode(): ?FileGenerator
    {
        $file = new FileGenerator();
        $class = new ClassGenerator();
        $file->setClass($class);
        $file->setNamespace($this->generatedDaoNamespace);

        $tableName = $this->table->getName();

        $primaryKeyColumns = TDBMDaoGenerator::getPrimaryKeyColumnsOrFail($this->table);

        list($defaultSort, $defaultSortDirection) = $this->getDefaultSortColumnFromAnnotation($this->table);

        $className = $this->namingStrategy->getDaoClassName($tableName);
        $baseClassName = $this->namingStrategy->getBaseDaoClassName($tableName);
        $beanClassWithoutNameSpace = $this->namingStrategy->getBeanClassName($tableName);
        $beanClassName = $this->beanNamespace.'\\'.$beanClassWithoutNameSpace;

        $findByDaoCodeMethods = $this->generateFindByDaoCode($this->beanNamespace, $beanClassWithoutNameSpace, $class);

        $usedBeans[] = $beanClassName;

$usedBeans was never initialized. Although not strictly required by PHP, it is generally a good practice to add $usedBeans = array(); before regardless.

        // Let's suppress duplicates in used beans (if any)
        $usedBeans = array_flip(array_flip($usedBeans));
        foreach ($usedBeans as $usedBean) {
            $class->addUse($usedBean);
        }

        $file->setDocBlock(new DocBlockGenerator(<<<EOF
This file has been automatically generated by TDBM.
DO NOT edit this file, as it might be overwritten.
If you need to perform changes, edit the $className class instead!
EOF
        ));

        $file->setNamespace($this->generatedDaoNamespace);

        $class->addUse(TDBMService::class);
        $class->addUse(ResultIterator::class);
        $class->addUse(TDBMException::class);

        $class->setName($baseClassName);

        $class->setDocBlock(new DocBlockGenerator("The $baseClassName class will maintain the persistence of $beanClassWithoutNameSpace class into the $tableName table."));

        $tdbmServiceProperty = new PropertyGenerator('tdbmService');
        $tdbmServiceProperty->setDocBlock(new DocBlockGenerator(null, null, [new VarTag(null, ['\\'.TDBMService::class])]));
        $class->addPropertyFromGenerator($tdbmServiceProperty);

        $defaultSortProperty = new PropertyGenerator('defaultSort', $defaultSort);
        $defaultSortProperty->setDocBlock(new DocBlockGenerator('The default sort column.', null, [new VarTag(null, ['string', 'null'])]));
        $class->addPropertyFromGenerator($defaultSortProperty);

        $defaultSortPropertyDirection = new PropertyGenerator('defaultDirection', $defaultSort && $defaultSortDirection ? $defaultSortDirection : 'asc');
        $defaultSortPropertyDirection->setDocBlock(new DocBlockGenerator('The default sort direction.', null, [new VarTag(null, ['string'])]));
        $class->addPropertyFromGenerator($defaultSortPropertyDirection);

        $constructorMethod = new MethodGenerator('__construct',
            [ new ParameterGenerator('tdbmService', TDBMService::class) ],
            MethodGenerator::FLAG_PUBLIC,
            '$this->tdbmService = $tdbmService;',
            'Sets the TDBM service used by this DAO.');
        $constructorMethod = $this->codeGeneratorListener->onBaseDaoConstructorGenerated($constructorMethod, $this, $this->configuration, $class);
        if ($constructorMethod !== null) {
            $class->addMethodFromGenerator($constructorMethod);
        }

        $saveMethod = new MethodGenerator(
            'save',
            [ new ParameterGenerator('obj', $beanClassName) ],
            MethodGenerator::FLAG_PUBLIC,
            '$this->tdbmService->save($obj);',
            new DocBlockGenerator("Persist the $beanClassWithoutNameSpace instance.",
                null,
                [
                    new ParamTag('obj', [$beanClassWithoutNameSpace], 'The bean to save.')
                ]));
        $saveMethod->setReturnType('void');

        $saveMethod = $this->codeGeneratorListener->onBaseDaoSaveGenerated($saveMethod, $this, $this->configuration, $class);
        if ($saveMethod !== null) {
            $class->addMethodFromGenerator($saveMethod);
        }

        $findAllBody = <<<EOF
if (\$this->defaultSort) {
    \$orderBy = '$tableName.'.\$this->defaultSort.' '.\$this->defaultDirection;
} else {
    \$orderBy = null;
}
return \$this->tdbmService->findObjects('$tableName', null, [], \$orderBy);
EOF;

        $findAllMethod = new MethodGenerator(
            'findAll',
            [],
            MethodGenerator::FLAG_PUBLIC,
            $findAllBody,
            (new DocBlockGenerator("Get all $beanClassWithoutNameSpace records.",
                null,
                [
                    new ReturnTag([ '\\'.$beanClassName.'[]', '\\'.ResultIterator::class ])
                ]))->setWordWrap(false)
        );
        $findAllMethod->setReturnType('\\'.ResultIterator::class);
        $findAllMethod = $this->codeGeneratorListener->onBaseDaoFindAllGenerated($findAllMethod, $this, $this->configuration, $class);
        if ($findAllMethod !== null) {
            $class->addMethodFromGenerator($findAllMethod);
        }

        if (count($primaryKeyColumns) === 1) {
            $primaryKeyColumn = $primaryKeyColumns[0];
            $primaryKeyPhpType = TDBMDaoGenerator::dbalTypeToPhpType($this->table->getColumn($primaryKeyColumn)->getType());

            $getByIdMethod = new MethodGenerator(
                'getById',
                [
                    new ParameterGenerator('id', $primaryKeyPhpType),
                    new ParameterGenerator('lazyLoading', 'bool', false)
                ],
                MethodGenerator::FLAG_PUBLIC,
                "return \$this->tdbmService->findObjectByPk('$tableName', ['$primaryKeyColumn' => \$id], [], \$lazyLoading);",
                (new DocBlockGenerator("Get $beanClassWithoutNameSpace specified by its ID (its primary key).",
                    'If the primary key does not exist, an exception is thrown.',
                    [
                        new ParamTag('id', [$primaryKeyPhpType]),
                        new ParamTag('lazyLoading', ['bool'], 'If set to true, the object will not be loaded right away. Instead, it will be loaded when you first try to access a method of the object.'),
                        new ReturnTag(['\\'.$beanClassName]),
                        new ThrowsTag('\\'.TDBMException::class)
                    ]))->setWordWrap(false)
            );
            $getByIdMethod->setReturnType($beanClassName);
            $getByIdMethod = $this->codeGeneratorListener->onBaseDaoGetByIdGenerated($getByIdMethod, $this, $this->configuration, $class);
            if ($getByIdMethod) {
                $class->addMethodFromGenerator($getByIdMethod);
            }
        }

        $deleteMethodBody = <<<EOF
if (\$cascade === true) {
    \$this->tdbmService->deleteCascade(\$obj);
} else {
    \$this->tdbmService->delete(\$obj);
}
EOF;


        $deleteMethod = new MethodGenerator(
            'delete',
            [
                new ParameterGenerator('obj', $beanClassName),
                new ParameterGenerator('cascade', 'bool', false)
            ],
            MethodGenerator::FLAG_PUBLIC,
            $deleteMethodBody,
            (new DocBlockGenerator("Get all $beanClassWithoutNameSpace records.",
                null,
                [
                    new ParamTag('obj', ['\\'.$beanClassName], 'The object to delete'),
                    new ParamTag('cascade', ['bool'], 'If true, it will delete all objects linked to $obj'),
                ]))->setWordWrap(false)
        );
        $deleteMethod->setReturnType('void');
        $deleteMethod = $this->codeGeneratorListener->onBaseDaoDeleteGenerated($deleteMethod, $this, $this->configuration, $class);
        if ($deleteMethod !== null) {
            $class->addMethodFromGenerator($deleteMethod);
        }

        $findMethodBody = <<<EOF
if (\$this->defaultSort && \$orderBy == null) {
    \$orderBy = '$tableName.'.\$this->defaultSort.' '.\$this->defaultDirection;
}
return \$this->tdbmService->findObjects('$tableName', \$filter, \$parameters, \$orderBy, \$additionalTablesFetch, \$mode);
EOF;


        $findMethod = new MethodGenerator(
            'find',
            [
                (new ParameterGenerator('filter'))->setDefaultValue(null),
                new ParameterGenerator('parameters', 'array', []),
                (new ParameterGenerator('orderBy'))->setDefaultValue(null),
                new ParameterGenerator('additionalTablesFetch', 'array', []),
                (new ParameterGenerator('mode', '?int'))->setDefaultValue(null),
            ],
            MethodGenerator::FLAG_PROTECTED,
            $findMethodBody,
            (new DocBlockGenerator("Get all $beanClassWithoutNameSpace records.",
                null,
                [
                    new ParamTag('filter', ['mixed'], 'The filter bag (see TDBMService::findObjects for complete description)'),
                    new ParamTag('parameters', ['mixed[]'], 'The parameters associated with the filter'),
                    new ParamTag('orderBy', ['mixed'], 'The order string'),
                    new ParamTag('additionalTablesFetch', ['string[]'], 'A list of additional tables to fetch (for performance improvement)'),
                    new ParamTag('mode', ['int', 'null'], 'Either TDBMService::MODE_ARRAY or TDBMService::MODE_CURSOR (for large datasets). Defaults to TDBMService::MODE_ARRAY.'),
                    new ReturnTag(['\\' . $beanClassName . '[]', '\\'.ResultIterator::class])
                ]))->setWordWrap(false)
        );
        $findMethod->setReturnType('\\'.ResultIterator::class);
        $findMethod = $this->codeGeneratorListener->onBaseDaoFindGenerated($findMethod, $this, $this->configuration, $class);
        if ($findMethod !== null) {
            $class->addMethodFromGenerator($findMethod);
        }

        $findFromSqlMethodBody = <<<EOF
if (\$this->defaultSort && \$orderBy == null) {
    \$orderBy = '$tableName.'.\$this->defaultSort.' '.\$this->defaultDirection;
}
return \$this->tdbmService->findObjectsFromSql('$tableName', \$from, \$filter, \$parameters, \$orderBy, \$mode);
EOF;

        $findFromSqlMethod = new MethodGenerator(
            'findFromSql',
            [
                new ParameterGenerator('from', 'string'),
                (new ParameterGenerator('filter'))->setDefaultValue(null),
                new ParameterGenerator('parameters', 'array', []),
                (new ParameterGenerator('orderBy'))->setDefaultValue(null),
                new ParameterGenerator('additionalTablesFetch', 'array', []),
                (new ParameterGenerator('mode', '?int'))->setDefaultValue(null),
            ],
            MethodGenerator::FLAG_PROTECTED,
            $findFromSqlMethodBody,
            (new DocBlockGenerator("Get a list of $beanClassWithoutNameSpace specified by its filters.",
                "Unlike the `find` method that guesses the FROM part of the statement, here you can pass the \$from part.

You should not put an alias on the main table name. So your \$from variable should look like:

   \"$tableName JOIN ... ON ...\"",
                [
                    new ParamTag('from', ['string'], 'The sql from statement'),
                    new ParamTag('filter', ['mixed'], 'The filter bag (see TDBMService::findObjects for complete description)'),
                    new ParamTag('parameters', ['mixed[]'], 'The parameters associated with the filter'),
                    new ParamTag('orderBy', ['mixed'], 'The order string'),
                    new ParamTag('additionalTablesFetch', ['string[]'], 'A list of additional tables to fetch (for performance improvement)'),
                    new ParamTag('mode', ['int', 'null'], 'Either TDBMService::MODE_ARRAY or TDBMService::MODE_CURSOR (for large datasets). Defaults to TDBMService::MODE_ARRAY.'),
                    new ReturnTag(['\\'.$beanClassName . '[]', '\\'.ResultIterator::class])
                ]))->setWordWrap(false)
        );
        $findFromSqlMethod->setReturnType('\\'.ResultIterator::class);
        $findFromSqlMethod = $this->codeGeneratorListener->onBaseDaoFindFromSqlGenerated($findFromSqlMethod, $this, $this->configuration, $class);
        if ($findFromSqlMethod !== null) {
            $class->addMethodFromGenerator($findFromSqlMethod);
        }

        $findFromRawSqlMethodBody = <<<EOF
return \$this->tdbmService->findObjectsFromRawSql('$tableName', \$sql, \$parameters, \$mode, null, \$countSql);
EOF;

        $findFromRawSqlMethod = new MethodGenerator(
            'findFromRawSql',
            [
                new ParameterGenerator('sql', 'string'),
                new ParameterGenerator('parameters', 'array', []),
                (new ParameterGenerator('countSql', '?string'))->setDefaultValue(null),
                (new ParameterGenerator('mode', '?int'))->setDefaultValue(null),
            ],
            MethodGenerator::FLAG_PROTECTED,
            $findFromRawSqlMethodBody,
            (new DocBlockGenerator("Get a list of $beanClassWithoutNameSpace from a SQL query.",
                "Unlike the `find` and `findFromSql` methods, here you can pass the whole \$sql query.

You should not put an alias on the main table name, and select its columns using `*`. So the SELECT part of you \$sql should look like:

   \"SELECT $tableName .* FROM ...\"",
                [
                    new ParamTag('sql', ['string'], 'The sql query'),
                    new ParamTag('parameters', ['mixed[]'], 'The parameters associated with the query'),
                    new ParamTag('countSql', ['string', 'null'], 'The sql query that provides total count of rows (automatically computed if not provided)'),
                    new ParamTag('mode', ['int', 'null'], 'Either TDBMService::MODE_ARRAY or TDBMService::MODE_CURSOR (for large datasets). Defaults to TDBMService::MODE_ARRAY.'),
                    new ReturnTag(['\\'.$beanClassName . '[]', '\\'.ResultIterator::class])
                ]))->setWordWrap(false)
        );
        $findFromRawSqlMethod->setReturnType('\\'.ResultIterator::class);
        $findFromRawSqlMethod = $this->codeGeneratorListener->onBaseDaoFindFromRawSqlGenerated($findFromRawSqlMethod, $this, $this->configuration, $class);
        if ($findFromRawSqlMethod !== null) {
            $class->addMethodFromGenerator($findFromRawSqlMethod);
        }

        $findOneMethodBody = <<<EOF
return \$this->tdbmService->findObject('$tableName', \$filter, \$parameters, \$additionalTablesFetch);
EOF;


        $findOneMethod = new MethodGenerator(
            'findOne',
            [
                (new ParameterGenerator('filter'))->setDefaultValue(null),
                new ParameterGenerator('parameters', 'array', []),
                new ParameterGenerator('additionalTablesFetch', 'array', []),
            ],
            MethodGenerator::FLAG_PROTECTED,
            $findOneMethodBody,
            (new DocBlockGenerator("Get a single $beanClassWithoutNameSpace specified by its filters.",
                null,
                [
                    new ParamTag('filter', ['mixed'], 'The filter bag (see TDBMService::findObjects for complete description)'),
                    new ParamTag('parameters', ['mixed[]'], 'The parameters associated with the filter'),
                    new ParamTag('additionalTablesFetch', ['string[]'], 'A list of additional tables to fetch (for performance improvement)'),
                    new ReturnTag(['\\'.$beanClassName, 'null'])
                ]))->setWordWrap(false)
        );
        $findOneMethod->setReturnType("?$beanClassName");
        $findOneMethod = $this->codeGeneratorListener->onBaseDaoFindOneGenerated($findOneMethod, $this, $this->configuration, $class);
        if ($findOneMethod !== null) {
            $class->addMethodFromGenerator($findOneMethod);
        }

        $findOneFromSqlMethodBody = <<<EOF
return \$this->tdbmService->findObjectFromSql('$tableName', \$from, \$filter, \$parameters);
EOF;

        $findOneFromSqlMethod = new MethodGenerator(
            'findOneFromSql',
            [
                new ParameterGenerator('from', 'string'),
                (new ParameterGenerator('filter'))->setDefaultValue(null),
                new ParameterGenerator('parameters', 'array', []),
            ],
            MethodGenerator::FLAG_PROTECTED,
            $findOneFromSqlMethodBody,
            new DocBlockGenerator("Get a single $beanClassWithoutNameSpace specified by its filters.",
                "Unlike the `findOne` method that guesses the FROM part of the statement, here you can pass the \$from part.

You should not put an alias on the main table name. So your \$from variable should look like:

    \"$tableName JOIN ... ON ...\"",
                [
                    new ParamTag('from', ['string'], 'The sql from statement'),
                    new ParamTag('filter', ['mixed'], 'The filter bag (see TDBMService::findObjects for complete description)'),
                    new ParamTag('parameters', ['mixed[]'], 'The parameters associated with the filter'),
                    new ReturnTag(['\\'.$beanClassName, 'null'])
                ])
        );
        $findOneFromSqlMethod->setReturnType("?$beanClassName");
        $findOneFromSqlMethod = $this->codeGeneratorListener->onBaseDaoFindOneFromSqlGenerated($findOneFromSqlMethod, $this, $this->configuration, $class);
        if ($findOneFromSqlMethod !== null) {
            $class->addMethodFromGenerator($findOneFromSqlMethod);
        }


        $setDefaultSortMethod = new MethodGenerator(
            'setDefaultSort',
            [
                new ParameterGenerator('defaultSort', 'string'),
            ],
            MethodGenerator::FLAG_PUBLIC,
            '$this->defaultSort = $defaultSort;',
            new DocBlockGenerator("Sets the default column for default sorting.",
            null,
                [
                    new ParamTag('defaultSort', ['string']),
                ])
        );
        $setDefaultSortMethod->setReturnType('void');
        $setDefaultSortMethod = $this->codeGeneratorListener->onBaseDaoSetDefaultSortGenerated($setDefaultSortMethod, $this, $this->configuration, $class);
        if ($setDefaultSortMethod !== null) {
            $class->addMethodFromGenerator($setDefaultSortMethod);
        }

        foreach ($findByDaoCodeMethods as $method) {
            $class->addMethodFromGenerator($method);
        }

        $file = $this->codeGeneratorListener->onBaseDaoGenerated($file, $this, $this->configuration);

        return $file;
    }

    /**
     * Tries to find a @defaultSort annotation in one of the columns.
     *
     * @param Table $table
     *
     * @return mixed[] First item: column name, Second item: column order (asc/desc)
     */
    private function getDefaultSortColumnFromAnnotation(Table $table): array
    {
        $defaultSort = null;
        $defaultSortDirection = null;
        foreach ($table->getColumns() as $column) {
            $comments = $column->getComment();
            $matches = [];
            if ($comments !== null && preg_match('/@defaultSort(\((desc|asc)\))*/', $comments, $matches) != 0) {
                $defaultSort = $column->getName();
                if (count($matches) === 3) {
                    $defaultSortDirection = $matches[2];
                } else {
                    $defaultSortDirection = 'ASC';
                }
            }
        }

        return [$defaultSort, $defaultSortDirection];
    }

    /**
     * @param string $beanNamespace
     * @param string $beanClassName
     *
     * @return MethodGenerator[]
     */
    private function generateFindByDaoCode(string $beanNamespace, string $beanClassName, ClassGenerator $class): array
    {
        $methods = [];
        foreach ($this->removeDuplicateIndexes($this->table->getIndexes()) as $index) {
            if (!$index->isPrimary()) {
                $method = $this->generateFindByDaoCodeForIndex($index, $beanNamespace, $beanClassName);

                if ($method !== null) {
                    $method = $this->codeGeneratorListener->onBaseDaoFindByIndexGenerated($method, $index, $this, $this->configuration, $class);
                    if ($method !== null) {
                        $methods[] = $method;
                    }
                }
            }
        }

        return $methods;
    }

    /**
     * Remove identical indexes (indexes on same columns)
     *
     * @param Index[] $indexes
     * @return Index[]
     */
    private function removeDuplicateIndexes(array $indexes): array
    {
        $indexesByKey = [];
        foreach ($indexes as $index) {
            $indexesByKey[implode('__`__', $index->getUnquotedColumns())] = $index;
        }

        return array_values($indexesByKey);
    }

    /**
     * @param Index  $index
     * @param string $beanNamespace
     * @param string $beanClassName
     *
     * @return MethodGenerator|null
     */
    private function generateFindByDaoCodeForIndex(Index $index, string $beanNamespace, string $beanClassName): ?MethodGenerator
    {
        $columns = $index->getColumns();
        $usedBeans = [];

        /**
         * The list of elements building this index (expressed as columns or foreign keys)
         * @var AbstractBeanPropertyDescriptor[]
         */
        $elements = [];

        foreach ($columns as $column) {
            $fk = $this->isPartOfForeignKey($this->table, $this->table->getColumn($column));
            if ($fk !== null) {
                if (!in_array($fk, $elements)) {
                    $elements[] = new ObjectBeanPropertyDescriptor($this->table, $fk, $this->namingStrategy, $this->beanNamespace, $this->annotationParser);
                }
            } else {
                $elements[] = new ScalarBeanPropertyDescriptor($this->table, $this->table->getColumn($column), $this->namingStrategy, $this->annotationParser);
            }
        }

        // If the index is actually only a foreign key, let's bypass it entirely.
        if (count($elements) === 1 && $elements[0] instanceof ObjectBeanPropertyDescriptor) {
            return null;
        }

        $parameters = [];
        //$functionParameters = [];
        $first = true;
        foreach ($elements as $element) {
            $parameter = new ParameterGenerator(ltrim($element->getVariableName(), '$'));
            if (!$first) {
                $parameterType = '?';
                //$functionParameter = '?';
            } else {
                $parameterType = '';
                //$functionParameter = '';
            }
            $parameterType .= $element->getPhpType();
            $parameter->setType($parameterType);
            if (!$first) {
                $parameter->setDefaultValue(null);
            }
            //$functionParameter .= $element->getPhpType();
            $elementClassName = $element->getClassName();
            if ($elementClassName) {
                $usedBeans[] = $beanNamespace.'\\'.$elementClassName;
            }
            //$functionParameter .= ' '.$element->getVariableName();
            if ($first) {
                $first = false;
            } /*else {
                $functionParameter .= ' = null';
            }*/
            //$functionParameters[] = $functionParameter;
            $parameters[] = $parameter;
        }

        //$functionParametersString = implode(', ', $functionParameters);

        $count = 0;

        $params = [];
        $filterArrayCode = '';
        $commentArguments = [];
        $first = true;
        foreach ($elements as $element) {
            $params[] = $element->getParamAnnotation();
            if ($element instanceof ScalarBeanPropertyDescriptor) {
                $filterArrayCode .= '            '.var_export($element->getColumnName(), true).' => '.$element->getVariableName().",\n";
            } elseif ($element instanceof ObjectBeanPropertyDescriptor) {
                $foreignKey = $element->getForeignKey();
                $columns = SafeFunctions::arrayCombine($foreignKey->getLocalColumns(), $foreignKey->getForeignColumns());
                ++$count;
                $foreignTable = $this->schema->getTable($foreignKey->getForeignTableName());
                foreach ($columns as $localColumn => $foreignColumn) {
                    // TODO: a foreign key could point to another foreign key. In this case, there is no getter for the pointed column. We don't support this case.
                    $targetedElement = new ScalarBeanPropertyDescriptor($foreignTable, $foreignTable->getColumn($foreignColumn), $this->namingStrategy, $this->annotationParser);
                    if ($first) {
                        // First parameter for index is not nullable
                        $filterArrayCode .= '            '.var_export($localColumn, true).' => '.$element->getVariableName().'->'.$targetedElement->getGetterName()."(),\n";
                    } else {
                        // Other parameters for index is not nullable
                        $filterArrayCode .= '            '.var_export($localColumn, true).' => ('.$element->getVariableName().' !== null) ? '.$element->getVariableName().'->'.$targetedElement->getGetterName()."() : null,\n";
                    }
                }
            }
            $commentArguments[] = substr($element->getVariableName(), 1);
            if ($first) {
                $first = false;
            }
        }

        //$paramsString = implode("\n", $params);


        $methodName = $this->namingStrategy->getFindByIndexMethodName($index, $elements);

        $method = new MethodGenerator($methodName);

        if ($index->isUnique()) {
            $parameters[] = new ParameterGenerator('additionalTablesFetch', 'array', []);
            $params[] = new ParamTag('additionalTablesFetch', [ 'string[]' ], 'A list of additional tables to fetch (for performance improvement)');
            $params[] = new ReturnTag([ '\\'.$beanNamespace.'\\'.$beanClassName, 'null' ]);
            $method->setReturnType('?\\'.$beanNamespace.'\\'.$beanClassName);

            $docBlock = new DocBlockGenerator("Get a $beanClassName filtered by ".implode(', ', $commentArguments). '.', null, $params);
            $docBlock->setWordWrap(false);

            $body = "\$filter = [
".$filterArrayCode."        ];
return \$this->findOne(\$filter, [], \$additionalTablesFetch);
";
        } else {
            $parameters[] = (new ParameterGenerator('orderBy'))->setDefaultValue(null);
            $params[] = new ParamTag('orderBy', [ 'mixed' ], 'The order string');
            $parameters[] = new ParameterGenerator('additionalTablesFetch', 'array', []);
            $params[] = new ParamTag('additionalTablesFetch', [ 'string[]' ], 'A list of additional tables to fetch (for performance improvement)');
            $parameters[] = (new ParameterGenerator('mode', '?int'))->setDefaultValue(null);
            $params[] = new ParamTag('mode', [ 'int', 'null' ], 'Either TDBMService::MODE_ARRAY or TDBMService::MODE_CURSOR (for large datasets). Defaults to TDBMService::MODE_ARRAY.');
            $params[] = new ReturnTag([ '\\'.$beanNamespace.'\\'.$beanClassName.'[]', '\\'.ResultIterator::class ]);
            $method->setReturnType('\\'.ResultIterator::class);

            $docBlock = new DocBlockGenerator("Get a list of $beanClassName filtered by ".implode(', ', $commentArguments).".", null, $params);
            $docBlock->setWordWrap(false);

            $body = "\$filter = [
".$filterArrayCode."        ];
return \$this->find(\$filter, [], \$orderBy, \$additionalTablesFetch, \$mode);
";
        }

        $method->setParameters($parameters);
        $method->setDocBlock($docBlock);
        $method->setBody($body);

        return $method;
    }

    /**
     * Generates the code for the getUsedTable protected method.
     *
     * @return MethodGenerator
     */
    private function generateGetUsedTablesCode(): MethodGenerator
    {
        $hasParentRelationship = $this->schemaAnalyzer->getParentRelationship($this->table->getName()) !== null;
        if ($hasParentRelationship) {
            $code = sprintf('$tables = parent::getUsedTables();
$tables[] = %s;

return $tables;', var_export($this->table->getName(), true));
        } else {
            $code = sprintf('        return [ %s ];', var_export($this->table->getName(), true));
        }

        $method = new MethodGenerator('getUsedTables');
        $method->setDocBlock('Returns an array of used tables by this bean (from parent to child relationship).');
        $method->getDocBlock()->setTag(new ReturnTag(['string[]']));
        $method->setReturnType('array');
        $method->setBody($code);

        return $method;
    }

    private function generateOnDeleteCode(): ?MethodGenerator
    {
        $code = '';
        $relationships = $this->getPropertiesForTable($this->table);
        foreach ($relationships as $relationship) {
            if ($relationship instanceof ObjectBeanPropertyDescriptor) {
                $tdbmFk = ForeignKey::createFromFk($relationship->getForeignKey());
                $code .= '$this->setRef('.var_export($tdbmFk->getCacheKey(), true).', null, '.var_export($this->table->getName(), true).");\n";
            }
        }

        if (!$code) {
            return null;
        }

        $method = new MethodGenerator('onDelete');
        $method->setDocBlock('Method called when the bean is removed from database.');
        $method->setReturnType('void');
        $method->setBody('parent::onDelete();
'.$code);

        return $method;
    }

    private function generateCloneCode(): MethodGenerator
    {
        $code = '';

        foreach ($this->beanPropertyDescriptors as $beanPropertyDescriptor) {
            $code .= $beanPropertyDescriptor->getCloneRule();
        }

        $method = new MethodGenerator('__clone');
        $method->setBody('parent::__clone();
'.$code);

        return $method;
    }

    /**
     * Returns the bean class name (without the namespace).
     *
     * @return string
     */
    public function getBeanClassName() : string
    {
        return $this->namingStrategy->getBeanClassName($this->table->getName());
    }

    /**
     * Returns the base bean class name (without the namespace).
     *
     * @return string
     */
    public function getBaseBeanClassName() : string
    {
        return $this->namingStrategy->getBaseBeanClassName($this->table->getName());
    }

    /**
     * Returns the DAO class name (without the namespace).
     *
     * @return string
     */
    public function getDaoClassName() : string
    {
        return $this->namingStrategy->getDaoClassName($this->table->getName());
    }

    /**
     * Returns the base DAO class name (without the namespace).
     *
     * @return string
     */
    public function getBaseDaoClassName() : string
    {
        return $this->namingStrategy->getBaseDaoClassName($this->table->getName());
    }

    /**
     * Returns the table used to build this bean.
     *
     * @return Table
     */
    public function getTable(): Table
    {
        return $this->table;
    }

    /**
     * Returns the extended bean class name (without the namespace), or null if the bean is not extended.
     *
     * @return string
     */
    public function getExtendedBeanClassName(): ?string
    {
        $parentFk = $this->schemaAnalyzer->getParentRelationship($this->table->getName());
        if ($parentFk !== null) {
            return $this->namingStrategy->getBeanClassName($parentFk->getForeignTableName());
        } else {
            return null;
        }
    }

    /**
     * @return string
     */
    public function getBeanNamespace(): string
    {
        return $this->beanNamespace;
    }

    /**
     * @return string
     */
    public function getGeneratedBeanNamespace(): string
    {
        return $this->generatedBeanNamespace;
    }

    /**
     * @param ForeignKeyConstraint[] $fks
     */
    private function generateGetForeignKeys(array $fks): MethodGenerator
    {
        $fkArray = [];

        foreach ($fks as $fk) {
            $tdbmFk = ForeignKey::createFromFk($fk);
            $fkArray[$tdbmFk->getCacheKey()] = [
                ForeignKey::FOREIGN_TABLE => $fk->getForeignTableName(),
                ForeignKey::LOCAL_COLUMNS => $fk->getUnquotedLocalColumns(),
                ForeignKey::FOREIGN_COLUMNS => $fk->getUnquotedForeignColumns(),
            ];
        }

        ksort($fkArray);
        foreach ($fkArray as $tableFks) {
            ksort($tableFks);
        }

        $code = <<<EOF
if (\$tableName === %s) {
    if (self::\$foreignKeys === null) {
        self::\$foreignKeys = new ForeignKeys(%s);
    }
    return self::\$foreignKeys;
}
return parent::getForeignKeys(\$tableName);
EOF;
        $code = sprintf($code, var_export($this->getTable()->getName(), true), $this->psr2VarExport($fkArray, '    '));

        $method = new MethodGenerator('getForeignKeys');
        $method->setVisibility(AbstractMemberGenerator::VISIBILITY_PROTECTED);
        $method->setStatic(true);
        $method->setDocBlock('Internal method used to retrieve the list of foreign keys attached to this bean.');
        $method->setReturnType(ForeignKeys::class);

        $parameter = new ParameterGenerator('tableName');
        $parameter->setType('string');
        $method->setParameter($parameter);


        $method->setBody($code);

        return $method;
    }

    /**
     * @param mixed $var
     * @param string $indent
     * @return string
     */
    private function psr2VarExport($var, string $indent=''): string
    {
        if (is_array($var)) {
            $indexed = array_keys($var) === range(0, count($var) - 1);
            $r = [];
            foreach ($var as $key => $value) {
                $r[] = "$indent    "
                    . ($indexed ? '' : $this->psr2VarExport($key) . ' => ')
                    . $this->psr2VarExport($value, "$indent    ");
            }
            return "[\n" . implode(",\n", $r) . "\n" . $indent . ']';
        }
        return var_export($var, true);
    }
}