Fossilized Methods, by Exakat

Method

Level

public function dispatch($walker) { /**/ }

56

abstract public function start( ) ;

26

protected function configure( ) { /**/ }

26

abstract public function reset( ) ;

26

abstract public function getCategory( ) ;

26

abstract public function getTitle( ) ;

26

protected function execute(InputInterface $input, OutputInterface $output) { /**/ }

24

abstract function Start( ) ;

24

function __construct($Parent) { /**/ }

23

abstract public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker) ;

22

abstract public function getSQLDeclaration(array $fieldDeclaration, AbstractPlatform $platform) ;

20

abstract public function getName( ) ;

20

abstract public function parse(\Doctrine\ORM\Query\Parser $parser) ;

20

public function convertToPHPValue($value, AbstractPlatform $platform) { /**/ }

19

function walkSelectStatement(AST\SelectStatement $AST) ;

14

public function connect(array $params, $username = null, $password = null, array $driverOptions = array( )) ;

12

abstract function Present( ) ;

12

public function getDatabase(Connection $conn) ;

12

public function getName( ) ;

12

public function getSchemaManager(Connection $conn) ;

12

public function getDatabasePlatform( ) ;

12

abstract public function getClobTypeDeclarationSQL(array $field) ;

11

abstract protected function doFetch($id) ;

11

abstract protected function initializeDoctrineTypeMappings( ) ;

11

abstract protected function doSave($id, $data, $lifeTime = false) ;

11

abstract protected function doContains($id) ;

11

public function getDateTimeTypeDeclarationSQL(array $fieldDeclaration) { /**/ }

11

public function getTimeTypeDeclarationSQL(array $fieldDeclaration) { /**/ }

11

public function getDateTypeDeclarationSQL(array $fieldDeclaration) { /**/ }

11

function setFetchMode($fetchMode, $arg2 = null, $arg3 = null) ;

10

function query( ) ;

10

function prepare($prepareString) ;

10

abstract protected function doDelete($id) ;

10

abstract protected function doFlush( ) ;

10

abstract protected function doGetStats( ) ;

10

public function convertToDatabaseValue($value, AbstractPlatform $platform) { /**/ }

10

abstract public function getName( ) ;

9

public function getListTableIndexesSQL($table, $currentDatabase = null) { /**/ }

9

abstract protected function _getCommonIntegerTypeDeclarationSQL(array $columnDef) ;

9

public function getListTablesSQL( ) { /**/ }

9

public function getLocateExpression($str, $substr, $startPos = false) { /**/ }

9

abstract public function getSmallIntTypeDeclarationSQL(array $columnDef) ;

9

protected function getVarcharTypeDeclarationSQLSnippet($length, $fixed) { /**/ }

9

public function getListTableColumnsSQL($table, $database = null) { /**/ }

9

function closeCursor( ) ;

9

function fetchAll($fetchMode = null) ;

9

abstract public function getBooleanTypeDeclarationSQL(array $columnDef) ;

9

abstract public function getIntegerTypeDeclarationSQL(array $columnDef) ;

9

protected function _getPortableTableIndexesList($tableIndexRows, $tableName = null) { /**/ }

9

abstract public function getBigIntTypeDeclarationSQL(array $columnDef) ;

9

function fetchColumn($columnIndex = 0) ;

9

function columnCount( ) ;

9

function fetch($fetchMode = null) ;

9

abstract protected function _getPortableTableColumnDefinition($tableColumn) ;

9

public function getDropViewSQL($name) { /**/ }

8

public function getCreateViewSQL($name, $sql) { /**/ }

8

abstract protected function getKeywords( ) ;

8

public function getListTableForeignKeysSQL($table) { /**/ }

8

protected function _getPortableTableDefinition($table) { /**/ }

8

public function getListViewsSQL($database) { /**/ }

8

protected function _getPortableViewDefinition($view) { /**/ }

8

public function supportsIdentityColumns( ) { /**/ }

8

protected function _getCreateTableSQL($tableName, array $columns, array $options = array( )) { /**/ }

8

public function acceptSchema(Schema $schema) ;

8

public function __construct($query, $parserResult, array $queryComponents) ;

8

public function getAlterTableSQL(TableDiff $diff) { /**/ }

8

protected function getReservedKeywordsClass( ) { /**/ }

8

abstract public function getName( ) ;

8

public function acceptTable(Table $table) ;

8

public function getListDatabasesSQL( ) { /**/ }

8

function commit( ) ;

8

function beginTransaction( ) ;

8

function exec($statement) ;

8

function quote($input, $type = \PDO::PARAM_STR) ;

8

public function __construct($locator, $fileExtension = null) { /**/ }

8

function loadMetadataForClass($className, ClassMetadata $metadata) ;

8

abstract public function getBlobTypeDeclarationSQL(array $field) ;

8

public function acceptSequence(Sequence $sequence) ;

8

public function acceptIndex(Table $table, Index $index) ;

8

public function acceptForeignKey(Table $localTable, ForeignKeyConstraint $fkConstraint) ;

8

public function acceptColumn(Table $table, Column $column) ;

8

function rollBack( ) ;

8

public function getDropDatabaseSQL($database) { /**/ }

7

public function getRegexpExpression( ) { /**/ }

7

public function getDateSubMonthExpression($date, $months) { /**/ }

7

public function getDateAddMonthExpression($date, $months) { /**/ }

7

public function getDateSubDaysExpression($date, $days) { /**/ }

7

public function prefersIdentityColumns( ) { /**/ }

7

public function getDateAddDaysExpression($date, $days) { /**/ }

7

public function getDateDiffExpression($date1, $date2) { /**/ }

7

public function getSubstringExpression($value, $from, $length = null) { /**/ }

7

protected function _getPortableDatabaseDefinition($database) { /**/ }

7

abstract public function generate(EntityManager $em, $entity) ;

7

public function getCreateDatabaseSQL($database) { /**/ }

7

function rowCount( ) ;

7

public function getSetTransactionIsolationSQL($level) { /**/ }

7

abstract function Format($Data, $Request) ;

7

function execute($params = null) ;

7

function __construct( ) { /**/ }

7

function errorInfo( ) ;

7

function errorCode( ) ;

7

function bindParam($column, &$variable, $type = null, $length = null) ;

7

public function getDateTimeTzFormatString( ) { /**/ }

7

function bindValue($param, $value, $type = null) ;

7

function isTransient($className) ;

6

public function startQuery($sql, array $params = null, array $types = null) ;

6

public function stopQuery( ) ;

6

function getAllClassNames( ) ;

6

public function getListTableConstraintsSQL($table) { /**/ }

6

function getClassAnnotations(\ReflectionClass $class) ;

6

function getClassAnnotation(\ReflectionClass $class, $annotationName) ;

6

function errorInfo( ) ;

6

function getMethodAnnotation(\ReflectionMethod $method, $annotationName) ;

6

function getPropertyAnnotations(\ReflectionProperty $property) ;

6

function getPropertyAnnotation(\ReflectionProperty $property, $annotationName) ;

6

protected function _getPortableTableForeignKeyDefinition($tableForeignKey) { /**/ }

6

function setUp( ) { /**/ }

6

abstract function Format($Data) ;

6

abstract protected function hydrateAllData( ) ;

6

function getMethodAnnotations(\ReflectionMethod $method) ;

6

function lastInsertId($name = null) ;

6

function errorCode( ) ;

6

public function getGuidExpression( ) { /**/ }

6

public function getBindingType( ) { /**/ }

6

protected function JS( ) { /**/ }

5

protected function hydrateRowData(array $data, array &$cache, array &$result) { /**/ }

5

public function getTemporaryTableName($tableName) { /**/ }

5

public function isSecureCodingAllowed( ) { /**/ }

5

public function getCreateTemporaryTableSnippetSQL( ) { /**/ }

5

public function supportsReleaseSavepoints( ) { /**/ }

5

public function getDropForeignKeySQL($foreignKey, $table) { /**/ }

5

public function getDropIndexSQL($index, $table = null) { /**/ }

5

protected abstract function IsRootable( ) ;

5

protected abstract function IsTerminal( ) ;

5

public function __construct(InputDefinition $definition = null) { /**/ }

5

function getName( ) ;

5

public function requiresSQLCommentHint(AbstractPlatform $platform) { /**/ }

5

public function getDateTimeFormatString( ) { /**/ }

5

public function getForUpdateSQL( ) { /**/ }

5

public function getDateFormatString( ) { /**/ }

5

public function getTimeFormatString( ) { /**/ }

5

abstract public function exportClassMetadata(ClassMetadataInfo $metadata) ;

5

public function getEmptyIdentityInsertSQL($tableName, $identifierColumnName) { /**/ }

5

public function getConcatExpression( ) { /**/ }

5

public function getTruncateTableSQL($tableName, $cascade = false) { /**/ }

5

protected function doModifyLimitQuery($query, $limit, $offset) { /**/ }

5

public function convertBooleans($item) { /**/ }

5

abstract function exec($Query) ;

5

abstract public function execute(Connection $conn, array $params, array $types) ;

5

function __construct(DatabaseSetting $db) { /**/ }

5

abstract function LastID( ) ;

5

abstract function query($QueryString) ;

5

abstract function quote($Param) ;

5

function walkPathExpression($pathExpr) ;

4

function getExecutor($AST) ;

4

public function getSequenceNextValSQL($sequenceName) { /**/ }

4

function walkResultVariable($resultVariable) ;

4

function walkArithmeticFactor($factor) ;

4

function walkSimpleArithmeticExpression($simpleArithmeticExpr) ;

4

function walkSimpleSelectClause($simpleSelectClause) ;

4

public function getDropSequenceSQL($sequence) { /**/ }

4

function walkAggregateExpression($aggExpression) ;

4

function walkStringPrimary($stringPrimary) ;

4

function walkArithmeticTerm($term) ;

4

function walkSimpleSelectExpression($simpleSelectExpression) ;

4

function walkQuantifiedExpression($qExpr) ;

4

function walkSubselectFromClause($subselectFromClause) ;

4

function walkSubselect($subselect) ;

4

function walkGroupByItem($groupByItem) ;

4

function walkSelectExpression($selectExpression) ;

4

function setVerbosity($level) ;

4

function walkJoin($join) ;

4

function getSubscribedEvents( ) ;

4

abstract protected function doWrite($message, $newline) ;

4

public function __construct($verbosity = self::VERBOSITY_NORMAL, $decorated = null, OutputFormatterInterface $formatter = null) { /**/ }

4

public function supportsCreateDropDatabase( ) { /**/ }

4

abstract public function walkCompositeExpression(CompositeExpression $expr) ;

4

function walkConditionalExpression($condExpr) ;

4

function walkOrderByItem($orderByItem) ;

4

function walkGroupByClause($groupByClause) ;

4

public function getNowExpression( ) { /**/ }

4

public function getTrimExpression($str, $pos = self::TRIM_UNSPECIFIED, $char = false) { /**/ }

4

abstract protected function getCatchablePatterns( ) ;

4

function walkConditionalTerm($condTerm) ;

4

function setFormatter(OutputFormatterInterface $formatter) ;

4

function walkConditionalFactor($factor) ;

4

function walkWhereClause($whereClause) ;

4

public function getListSequencesSQL($database) { /**/ }

4

function walkUpdateItem($updateItem) ;

4

function walkUpdateClause($updateClause) ;

4

function walkConditionalPrimary($primary) ;

4

function walkExistsExpression($existsExpr) ;

4

function walkDeleteClause(AST\DeleteClause $deleteClause) ;

4

function walkCollectionMemberExpression($collMemberExpr) ;

4

function walkEmptyCollectionComparisonExpression($emptyCollCompExpr) ;

4

function walkNullComparisonExpression($nullCompExpr) ;

4

function walkArithmeticExpression($arithmeticExpr) ;

4

function setDecorated($decorated) ;

4

function walkDeleteStatement(AST\DeleteStatement $AST) ;

4

function walkInExpression($inExpr) ;

4

function walkUpdateStatement(AST\UpdateStatement $AST) ;

4

abstract protected function PrepareStatement($Query) ;

4

function walkInstanceOfExpression($instanceOfExpr) ;

4

function walkLiteral($literal) ;

4

function walkBetweenExpression($betweenExpr) ;

4

function walkLikeExpression($likeExpr) ;

4

function walkStateFieldPathExpression($stateFieldPathExpression) ;

4

function walkComparisonExpression($compExpr) ;

4

function walkInputParameter($inputParam) ;

4

function walkFunction($function) ;

4

function walkOrderByClause($orderByClause) ;

4

function walkHavingClause($havingClause) ;

4

function walkFromClause($fromClause) ;

4

abstract protected function loadMappingFile($file) ;

4

abstract function bindAll( ) ;

4

abstract function execute( ) ;

4

abstract protected function executeSchemaCommand(InputInterface $input, OutputInterface $output, SchemaTool $schemaTool, array $metadatas) ;

4

abstract function testQuote( ) ;

4

protected function prepare( ) { /**/ }

4

abstract function Handle($RelativeRequest) ;

4

abstract function rowCount( ) ;

4

abstract protected function getNonCatchablePatterns( ) ;

4

abstract protected function getType(&$value) ;

4

function __construct($Username = null, $Password = null) { /**/ }

4

public function build( ) { /**/ }

4

public function supportsLimitOffset( ) { /**/ }

4

public function connect( ) { /**/ }

4

function matching(Criteria $criteria) ;

4

public function getShowDatabasesSQL( ) { /**/ }

4

public function releaseSavePoint($savepoint) { /**/ }

4

function walkSelectClause($selectClause) ;

4

protected function _getPortableUserDefinition($user) { /**/ }

4

public function getSQLResultCasing($column) { /**/ }

4

abstract public function walkValue(Value $value) ;

4

abstract public function walkComparison(Comparison $comparison) ;

4

abstract function fetch( ) ;

4

protected function _getPortableSequenceDefinition($sequence) { /**/ }

4

public function visit(ExpressionVisitor $visitor) ;

4

public function createDatabase($database) { /**/ }

4

function map(Closure $func) ;

3

function getShards( ) ;

3

function partition(Closure $p) ;

3

function indexOf($element) ;

3

abstract protected function Type( ) ;

3

function slice($offset, $length = null) ;

3

public function supportsSequences( ) { /**/ }

3

function selectGlobal( ) ;

3

function selectShard($distributionValue) ;

3

function getCurrentDistributionValue( ) ;

3

public function supportsInlineColumnComments( ) { /**/ }

3

function clear( ) ;

3

protected function _getTransactionIsolationLevelSQL($level) { /**/ }

3

function save($id, $data, $lifeTime = 0) ;

3

function queryAll($sql, array $params, array $types) ;

3

public function supportsCommentOnStatement( ) { /**/ }

3

abstract protected function _doExecute( ) ;

3

function contains($id) ;

3

protected abstract function Type( ) ;

3

public function rollbackSavePoint($savepoint) { /**/ }

3

function add($element) ;

3

function contains($element) ;

3

abstract public function getSQL( ) ;

3

function first( ) ;

3

function forAll(Closure $p) ;

3

function filter(Closure $p) ;

3

function exists(Closure $p) ;

3

function next( ) ;

3

public function createSavePoint($savepoint) { /**/ }

3

function current( ) ;

3

function key( ) ;

3

function delete($id) ;

3

function toArray( ) ;

3

function isEmpty( ) ;

3

function set($key, $value) ;

3

public function getDummySelectSQL( ) { /**/ }

3

function getValues( ) ;

3

function getKeys( ) ;

3

function get($key) ;

3

function containsKey($key) ;

3

public function getDateTimeTzTypeDeclarationSQL(array $fieldDeclaration) { /**/ }

3

function removeElement($element) ;

3

function remove($key) ;

3

function last( ) ;

3

protected abstract function Instance( ) ;

3

public function prefersSequences( ) { /**/ }

3

function getFileExtension( ) ;

3

public function __construct(array $params, Driver $driver, Configuration $config = null, EventManager $eventManager = null) { /**/ }

3

public function dropDatabase($database) { /**/ }

3

function findMappingFile($className) ;

3

function getAllClassNames($globalBasename) ;

3

function fileExists($className) ;

3

function getPaths( ) ;

3

public function getAdvancedForeignKeyOptionsSQL(ForeignKeyConstraint $foreignKey) { /**/ }

3

protected function _getInsertColumnList( ) { /**/ }

3

abstract protected function _getInsertRowSQLParameters(PersistentCollection $coll, $element) ;

3

protected function _getPortableTableForeignKeysList($tableForeignKeys) { /**/ }

3

abstract protected function _getInsertRowSQL(PersistentCollection $coll) ;

3

public function getColumns( ) ;

3

abstract protected function _getUpdateRowSQL(PersistentCollection $coll) ;

3

abstract protected function _getDeleteRowSQLParameters(PersistentCollection $coll, $element) ;

3

protected function _getSelectColumnListSQL( ) { /**/ }

3

function getParentClasses($class) ;

3

public function removeElement(PersistentCollection $coll, $element) { /**/ }

3

function joinColumnName($propertyName) ;

3

abstract protected function _getDiscriminatorColumnTableName( ) ;

3

public function isPostInsertGenerator( ) { /**/ }

3

function __construct( ) { /**/ }

3

function classToTableName($className) ;

3

function propertyToColumnName($propertyName) ;

3

function referenceColumnName( ) ;

3

function joinTableName($sourceEntity, $targetEntity, $propertyName = null) ;

3

protected function interact(InputInterface $input, OutputInterface $output) { /**/ }

3

function joinKeyColumnName($entityName, $referencedColumnName = null) ;

3

function hasPublicMethod($class, $method) ;

3

function getAccessibleProperty($class, $property) ;

3

function getClass($class) ;

3

function getClassNamespace($class) ;

3

function getClassShortName($class) ;

3

abstract protected function _getDeleteRowSQL(PersistentCollection $coll) ;

3

public function getDropTemporaryTableSQL($table) { /**/ }

3

public function contains(PersistentCollection $coll, $element) { /**/ }

3

public function slice(PersistentCollection $coll, $offset, $length = null) { /**/ }

3

abstract protected function parse( ) ;

3

function getFirstArgument( ) ;

3

protected function getCreateIndexSQLFlags(Index $index) { /**/ }

3

public function getCreateIndexSQL(Index $index, $table) { /**/ }

3

public function getAlterSequenceSQL(Sequence $sequence) { /**/ }

3

public function getCreateSequenceSQL(Sequence $sequence) { /**/ }

3

function hasParameterOption($values) ;

3

public function getModExpression($expression1, $expression2) { /**/ }

3

public function getReadLockSQL( ) { /**/ }

3

public function appendLockHint($fromClause, $lockMode) { /**/ }

3

public function getGuidTypeDeclarationSQL(array $field) { /**/ }

3

public function getIdentifierQuoteCharacter( ) { /**/ }

3

function getParameterOption($values, $default = false) ;

3

public function getVarcharMaxLength( ) { /**/ }

3

public function getDefaultValueDeclarationSQL($field) { /**/ }

3

public function getLengthExpression($column) { /**/ }

3

function fetch($id) ;

3

public function __construct(Connection $conn) { /**/ }

3

abstract protected function _getDeleteSQLParameters(PersistentCollection $coll) ;

3

public function count(PersistentCollection $coll) { /**/ }

3

function dropAllSchema( ) ;

3

function dropSchema(Schema $dropSchema) ;

3

function updateSchema(Schema $toSchema, $noDrops = false) ;

3

function createSchema(Schema $createSchema) ;

3

public function getUniqueConstraintDeclarationSQL($name, Index $index) { /**/ }

3

abstract protected function _getDeleteSQL(PersistentCollection $coll) ;

3

function getCreateSchema(Schema $createSchema) ;

3

function getDropAllSchema( ) ;

3

function getDropSchema(Schema $dropSchema) ;

3

function getUpdateSchema(Schema $toSchema, $noDrops = false) ;

3

abstract protected function newClassMetadataInstance($className) ;

2

function getIdentifier( ) ;

2

abstract protected function isEntity(ClassMetadata $class) ;

2

abstract protected function doLoadMetadata($class, $parent, $rootEntityFound, array $nonSuperclassParents) ;

2

function getName( ) ;

2

public function getReflectionService( ) { /**/ }

2

function prepare($QueryString) { /**/ }

2

function getReflectionClass( ) ;

2

function isAssociationInverseSide($assocName) ;

2

function getStats( ) ;

2

function InitializeData( ) { /**/ }

2

public function ListTables($All = false) { /**/ }

2

function DropTables( ) { /**/ }

2

function fetchAll( ) { /**/ }

2

function getIdentifierValues($object) ;

2

function getAssociationMappedByTargetField($assocName) ;

2

function getAssociationTargetClass($assocName) ;

2

function isIdentifier($fieldName) ;

2

function getTypeOfField($fieldName) ;

2

function getAssociationNames( ) ;

2

function getIdentifierFieldNames( ) ;

2

function getFieldNames( ) ;

2

function isCollectionValuedAssociation($fieldName) ;

2

function isSingleValuedAssociation($fieldName) ;

2

function hasAssociation($fieldName) ;

2

function hasField($fieldName) ;

2

protected function TruncateTables( ) { /**/ }

2

function isDecorated( ) ;

2

function __construct($Adapter, $DatabaseName, $Username, $Password, $Host = "localhost", $TablePrefix = "jf_") { /**/ }

2

function Login($Username, $Password) { /**/ }

2

function unsetOption($option) ;

2

function setOptions(array $options) ;

2

function apply($text) ;

2

function setDecorated($decorated) ;

2

function isDecorated( ) ;

2

function setStyle($name, OutputFormatterStyleInterface $style) ;

2

function hasStyle($name) ;

2

function getStyle($name) ;

2

function format($message) ;

2

function UserExists($Username) { /**/ }

2

protected function getNativeDefinition( ) { /**/ }

2

function setBackground($color = null) ;

2

protected function DumpClass( ) { /**/ }

2

protected function CSS( ) { /**/ }

2

function ForceLogin($UserID) { /**/ }

2

function EditUser($OldUsername, $NewUsername, $NewPassword = null) { /**/ }

2

function DeleteUser($Username) { /**/ }

2

function Value( ) { /**/ }

2

function SetValidation($Validation) { /**/ }

2

function Launch( ) { /**/ }

2

public static function setUpBeforeClass( ) { /**/ }

2

public static function setUpBeforeClass( ) { /**/ }

2

function setOption($option) ;

2

function setForeground($color = null) ;

2

function UserCount( ) { /**/ }

2

function getArguments( ) ;

2

function write($messages, $newline = false, $type = 0) ;

2

function writeln($messages, $type = 0) ;

2

function getVerbosity( ) ;

2

abstract protected function wakeupReflection(ClassMetadata $class, ReflectionService $reflService) ;

2

function getFormatter( ) ;

2

public function getErrorOutput( ) ;

2

public function setErrorOutput(OutputInterface $error) ;

2

function CreateUser($Username, $Password) { /**/ }

2

function bind(InputDefinition $definition) ;

2

function validate( ) ;

2

function getArgument($name) ;

2

function UserIDExists($UserID) { /**/ }

2

function setArgument($name, $value) ;

2

function hasArgument($name) ;

2

function getOptions( ) ;

2

function getOption($name) ;

2

function setOption($name, $value) ;

2

function hasOption($name) ;

2

function isInteractive( ) ;

2

function setInteractive($interactive) ;

2

function setHelperSet(HelperSet $helperSet = null) ;

2

function getHelperSet( ) ;

2

abstract protected function initializeReflection(ClassMetadata $class, ReflectionService $reflService) ;

2

protected function _getSelectConditionSQL(array $criteria, $assoc = null) { /**/ }

2

abstract protected function getDriver( ) ;

2

protected function getPreAlterTableIndexForeignKeySQL(TableDiff $diff) { /**/ }

2

protected function _getPortableFunctionDefinition($function) { /**/ }

2

protected function _getPortableTriggerDefinition($trigger) { /**/ }

2

public function update($entity) { /**/ }

2

protected function assignDefaultVersionValue($entity, $id) { /**/ }

2

protected function _getPortableTablesList($tables) { /**/ }

2

public function executeInserts( ) { /**/ }

2

public function getSchemaSearchPaths( ) { /**/ }

2

public function __toString( ) { /**/ }

2

public function getBitAndComparisonExpression($value1, $value2) { /**/ }

2

public function getBitOrComparisonExpression($value1, $value2) { /**/ }

2

public function getCreateTableSQL(Table $table, $createFlags = self::CREATE_INDEXES) { /**/ }

2

public function getCreatePrimaryKeySQL(Index $index, $table) { /**/ }

2

public function quoteIdentifier($str) { /**/ }

2

public function quoteSingleIdentifier($str) { /**/ }

2

public function getIndexDeclarationSQL($name, Index $index) { /**/ }

2

public function alterTable(TableDiff $tableDiff) { /**/ }

2

public function supportsSchemas( ) { /**/ }

2

public function iterate($parameters = null, $hydrationMode = null) { /**/ }

2

public function __clone( ) { /**/ }

2

public function getMaxIdentifierLength( ) { /**/ }

2

public function fixSchemaElementName($schemaElementName) { /**/ }

2

public function supportsViews( ) { /**/ }

2

public function canEmulateSchemas( ) { /**/ }

2

public function supportsForeignKeyOnUpdate( ) { /**/ }

2

public function getCurrentDateSQL( ) { /**/ }

2

public function supportsForeignKeyConstraints( ) { /**/ }

2

public function supportsSavepoints( ) { /**/ }

2

public function supportsAlterTable( ) { /**/ }

2

public function getListUsersSQL( ) { /**/ }

2

public function getCurrentTimestampSQL( ) { /**/ }

2

public function getCurrentTimeSQL( ) { /**/ }

2

public function delete($entity) { /**/ }

2

public function dropTable($table) { /**/ }

2

public function setHydrationMode($hydrationMode) { /**/ }

2

public function __construct($entity, EntityManager $em) { /**/ }

2

function getReferencedJoinColumnName(array $joinColumn, ClassMetadata $class, AbstractPlatform $platform) ;

2

function getJoinColumnName(array $joinColumn, ClassMetadata $class, AbstractPlatform $platform) ;

2

function getJoinTableName(array $association, ClassMetadata $class, AbstractPlatform $platform) ;

2

function getSequenceName(array $definition, ClassMetadata $class, AbstractPlatform $platform) ;

2

function getTableName(ClassMetadata $class, AbstractPlatform $platform) ;

2

function getColumnName($fieldName, ClassMetadata $class, AbstractPlatform $platform) ;

2

public function onClear($eventArgs) { /**/ }

2

function getColumnAlias($columnName, $counter, AbstractPlatform $platform, ClassMetadata $class = null) ;

2

protected function _getSelectColumnSQL($field, ClassMetadata $class, $alias = 'r') { /**/ }

2

protected function _getSQLTableAlias($className, $assocName = '') { /**/ }

2

protected function cleanup( ) { /**/ }

2

protected function getLockTablesSql( ) { /**/ }

2

protected function _generateOutputPath(ClassMetadataInfo $metadata) { /**/ }

2

protected function _getSelectConditionCriteriaSQL(Criteria $criteria) { /**/ }

2

function getIdentifierColumnNames(ClassMetadata $class, AbstractPlatform $platform) ;

2

function getAllClassNames( ) ;

2

public function listTableNames( ) { /**/ }

2

public function insert($tableName, array $data, array $types = array( )) { /**/ }

2

public function listTableIndexes($table) { /**/ }

2

public function rollbackSavepoint($savepoint) { /**/ }

2

public function releaseSavepoint($savepoint) { /**/ }

2

public function createSavepoint($savepoint) { /**/ }

2

public function executeUpdate($query, array $params = array( ), array $types = array( )) { /**/ }

2

public function executeQuery($query, array $params = array( ), $types = array( ), QueryCacheProfile $qcp = null) { /**/ }

2

public function update($tableName, array $data, array $identifier, array $types = array( )) { /**/ }

2

function isTransient($className) ;

2

public function close( ) { /**/ }

2

public function delete($tableName, array $identifier) { /**/ }

2

public function isConnected( ) { /**/ }

2

protected function _prepareInsertData($entity) { /**/ }

2

public function getOwningTable($fieldName) { /**/ }

2

protected function _getSelectEntitiesSQL($criteria, $assoc = null, $lockMode = 0, $limit = null, $offset = null, array $orderBy = null) { /**/ }

2

public function setHint($name, $value) { /**/ }

2

public function free( ) { /**/ }

2

abstract protected function getFqcnFromAlias($namespaceAlias, $simpleClassName) ;

2

function flush( ) ;

2

function getRepository($persistentObject, $persistentManagerName = null) ;

2

function getManagerForClass($class) ;

2

function find($id) ;

2

function findAll( ) ;

2

function findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null) ;

2

function findOneBy(array $criteria) ;

2

function getClassName( ) ;

2

function find($className, $id) ;

2

function persist($object) ;

2

function remove($object) ;

2

function merge($object) ;

2

function clear($objectName = null) ;

2

function detach($object) ;

2

function refresh($object) ;

2

function getRepository($className) ;

2

function resetManager($name = null) ;

2

public function __construct($entity, ObjectManager $objectManager) { /**/ }

2

abstract protected function initialize( ) ;

2

function isTransient($className) ;

2

function setMetadataFor($className, $class) ;

2

function hasMetadataFor($className) ;

2

function getMetadataFor($className) ;

2

function getAllMetadata( ) ;

2

function getConnectionNames( ) ;

2

function getClassMetadata($className) ;

2

function getConnections( ) ;

2

function getConnection($name = null) ;

2

function getDefaultConnectionName( ) ;

2

function contains($object) ;

2

function initializeObject($obj) ;

2

function getMetadataFactory( ) ;

2

function getManagerNames( ) ;

2

function getManagers( ) ;

2

public function getDefaultLength(AbstractPlatform $platform) { /**/ }

2

function DeleteConditional($ConditionString) ;

2

function ParentNode($ID) ;

2

function Sibling($ID, $SiblingDistance = 1) ;

2

function GetID($ConditionString) ;

2

function InsertChildData($FieldValueArray = array( ), $ConditionString = null) ;

2

function InsertSiblingData($FieldValueArray = array( ), $ConditionString = null) ;

2

function DeleteSubtreeConditional($ConditionString) ;

2

function ChildrenConditional($ConditionString) ;

2

protected function generateFilterConditionSQL(ClassMetadata $targetEntity, $targetTableAlias) { /**/ }

2

function DescendantsConditional($AbsoluteDepths = false, $ConditionString) ;

2

function LeavesConditional($ConditionString = null) ;

2

function PathConditional($ConditionString) ;

2

function DepthConditional($ConditionString) ;

2

function ParentNodeConditional($ConditionString) ;

2

function SiblingConditional($SiblingDistance = 1, $ConditionString) ;

2

function Depth($ID) ;

2

function Leaves($PID = null) ;

2

function getManager($name = null) ;

2

function propertyChanged($sender, $propertyName, $oldValue, $newValue) ;

2

function getDefaultManagerName( ) ;

2

public function injectObjectManager(ObjectManager $objectManager, ClassMetadata $classMetadata) ;

2

public function getReflectionProperty($name) ;

2

public function getReflectionMethod($name) ;

2

public function getReflectionClass( ) ;

2

public function findFile($class) ;

2

function pickShard($distributionValue, PoolingShardConnection $conn) ;

2

function Descendants($ID, $AbsoluteDepths = false) ;

2

public function InsertChild($PID = 0) ;

2

public function InsertSibling($ID = 0) ;

2

function DeleteSubtree($ID) ;

2

function Delete($ID) ;

2

function FullTree( ) ;

2

function Children($ID) ;

2

function Path($ID) ;

2

Method Fossilization