{

protected $entityNotFoundExceptionClass = '\\Propel\\Runtime\\Exception\\EntityNotFoundException';

/**

public function __construct($dbName = 'default', $modelName = '\\SOB\\Propel2\\Stringrecord', $modelAlias = null)

{

parent::__construct($dbName, $modelName, $modelAlias);

}

/**

public static function create(?string $modelAlias = null, ?Criteria $criteria = null) : Criteria

{

if ($criteria instanceof ChildStringrecordQuery) {

return $criteria;

}

$query = new ChildStringrecordQuery();

if (null !== $modelAlias) {

$query->setModelAlias($modelAlias);

}

if ($criteria instanceof Criteria) {

$query->mergeWith($criteria);

}

return $query;

}

/**

public function delete(?ConnectionInterface $con = null) : int

{

if (null === $con) {

$con = Propel::getServiceContainer()->getWriteConnection(StringrecordTableMap::DATABASE_NAME);

}

$criteria = $this;

// Set the correct dbName

$criteria->setDbName(StringrecordTableMap::DATABASE_NAME);

// use transaction because $criteria could contain info

// for more than one table or we could emulating ON DELETE CASCADE, etc.

return $con->transaction(function() use ($con, $criteria) {

$affectedRows = 0; // initialize var to track total num of affected rows

StringrecordTableMap::removeInstanceFromPool($criteria);

$affectedRows += parent::delete($con);

StringrecordTableMap::clearRelatedInstancePool();

return $affectedRows;

});

}

/**

public function doDeleteAll(?ConnectionInterface $con = null) : int

{

if (null === $con) {

$con = Propel::getServiceContainer()->getWriteConnection(StringrecordTableMap::DATABASE_NAME);

}

// use transaction because $criteria could contain info

// for more than one table or we could emulating ON DELETE CASCADE, etc.

return $con->transaction(function() use ($con) {

$affectedRows = 0; // initialize var to track total num of affected rows

$affectedRows += parent::doDeleteAll($con);

// Because this db requires some delete cascade/set null emulation, we have to

// clear the cached instance *after* the emulation has happened (since

// instances get re-added by the select statement contained therein).

StringrecordTableMap::clearInstancePool();

StringrecordTableMap::clearRelatedInstancePool();

return $affectedRows;

});

}

/**

public function filterByPrimaryKey($key)

{

$this->addUsingAlias(StringrecordTableMap::COL_STRINGRECORDID, $key, Criteria::EQUAL);

return $this;

}

/**

public function filterByPrimaryKeys($keys)

{

$this->addUsingAlias(StringrecordTableMap::COL_STRINGRECORDID, $keys, Criteria::IN);

return $this;

}

/**

public function filterByStringdefaultnotnull($stringdefaultnotnull = null, ?string $comparison = null)

{

if (null === $comparison) {

if (\is_array($stringdefaultnotnull)) {

$comparison = Criteria::IN;

}

}

$this->addUsingAlias(StringrecordTableMap::COL_STRINGDEFAULTNOTNULL, $stringdefaultnotnull, $comparison);

return $this;

}

/**

public function filterByStringdefaultnull($stringdefaultnull = null, ?string $comparison = null)

{

if (null === $comparison) {

if (\is_array($stringdefaultnull)) {

$comparison = Criteria::IN;

}

}

$this->addUsingAlias(StringrecordTableMap::COL_STRINGDEFAULTNULL, $stringdefaultnull, $comparison);

return $this;

}

/**

public function filterByStringdefaultnullable($stringdefaultnullable = null, ?string $comparison = null)

{

if (null === $comparison) {

if (\is_array($stringdefaultnullable)) {

$comparison = Criteria::IN;

}

}

$this->addUsingAlias(StringrecordTableMap::COL_STRINGDEFAULTNULLABLE, $stringdefaultnullable, $comparison);

return $this;

}

/**

public function filterByStringrecordid($stringrecordid = null, ?string $comparison = null)

{

if (\is_array($stringrecordid)) {

$useMinMax = false;

if (isset($stringrecordid['min'])) {

$this->addUsingAlias(StringrecordTableMap::COL_STRINGRECORDID, $stringrecordid['min'], Criteria::GREATER_EQUAL);

$useMinMax = true;

}

if (isset($stringrecordid['max'])) {

$this->addUsingAlias(StringrecordTableMap::COL_STRINGRECORDID, $stringrecordid['max'], Criteria::LESS_EQUAL);

$useMinMax = true;

}

if ($useMinMax) {

return $this;

}

if (null === $comparison) {

$comparison = Criteria::IN;

}

}

$this->addUsingAlias(StringrecordTableMap::COL_STRINGRECORDID, $stringrecordid, $comparison);

return $this;

}

/**

public function filterByStringrequired($stringrequired = null, ?string $comparison = null)

{

if (null === $comparison) {

if (\is_array($stringrequired)) {

$comparison = Criteria::IN;

}

}

$this->addUsingAlias(StringrecordTableMap::COL_STRINGREQUIRED, $stringrequired, $comparison);

return $this;

}

/**

public function findPk($key, ?ConnectionInterface $con = null)

{

if (null === $key) {

return null;

}

if (null === $con) {

$con = Propel::getServiceContainer()->getReadConnection(StringrecordTableMap::DATABASE_NAME);

}

$this->basePreSelect($con);

if (

$this->formatter || $this->modelAlias || $this->with || $this->select

|| $this->selectColumns || $this->asColumns || $this->selectModifiers

|| $this->map || $this->having || $this->joins

) {

return $this->findPkComplex($key, $con);

}

if ((null !== ($obj = StringrecordTableMap::getInstanceFromPool(null === $key || \is_scalar($key) || \is_callable([$key, '__toString']) ? (string)$key : $key)))) {

// the object is already in the instance pool

return $obj;

}

return $this->findPkSimple($key, $con);

}

/**

public function findPks($keys, ?ConnectionInterface $con = null)

{

if (null === $con) {

$con = Propel::getServiceContainer()->getReadConnection($this->getDbName());

}

$this->basePreSelect($con);

$criteria = $this->isKeepQuery() ? clone $this : $this;

$dataFetcher = $criteria

->filterByPrimaryKeys($keys)

->doSelect($con);

return $criteria->getFormatter()->init($criteria)->format($dataFetcher);

}

/**

public function prune($stringrecord = null)

{

if ($stringrecord) {

$this->addUsingAlias(StringrecordTableMap::COL_STRINGRECORDID, $stringrecord->getStringrecordid(), Criteria::NOT_EQUAL);

}

return $this;

}

/**

protected function findPkComplex($key, ConnectionInterface $con)

{

// As the query uses a PK condition, no limit(1) is necessary.

$criteria = $this->isKeepQuery() ? clone $this : $this;

$dataFetcher = $criteria

->filterByPrimaryKey($key)

->doSelect($con);

return $criteria->getFormatter()->init($criteria)->formatOne($dataFetcher);

}

/**

protected function findPkSimple($key, ConnectionInterface $con)

{

$sql = 'SELECT stringRecordId, stringRequired, stringDefaultNull, stringDefaultNullable, stringDefaultNotNull FROM stringrecord WHERE stringRecordId = :p0';

try {

$stmt = $con->prepare($sql);

$stmt->bindValue(':p0', $key, PDO::PARAM_INT);

$stmt->execute();

} catch (Exception $e) {

Propel::log($e->getMessage(), Propel::LOG_ERR);

throw new PropelException(\sprintf('Unable to execute SELECT statement [%s]', $sql), 0, $e);

}

$obj = null;

if ($row = $stmt->fetch(\PDO::FETCH_NUM)) {

/** @var ChildStringrecord $obj */

$obj = new ChildStringrecord();

$obj->hydrate($row);

StringrecordTableMap::addInstanceToPool($obj, null === $key || \is_scalar($key) || \is_callable([$key, '__toString']) ? (string)$key : $key);

}

$stmt->closeCursor();

return $obj;

}