<?php

namespace ArtabanMarketplace\Model\Base;

use \Exception;
use \PDO;
use ArtabanMarketplace\Model\AmpSellerOrderVersion as ChildAmpSellerOrderVersion;
use ArtabanMarketplace\Model\AmpSellerOrderVersionQuery as ChildAmpSellerOrderVersionQuery;
use ArtabanMarketplace\Model\Map\AmpSellerOrderVersionTableMap;
use Propel\Runtime\Propel;
use Propel\Runtime\ActiveQuery\Criteria;
use Propel\Runtime\ActiveQuery\ModelCriteria;
use Propel\Runtime\ActiveQuery\ModelJoin;
use Propel\Runtime\Collection\Collection;
use Propel\Runtime\Collection\ObjectCollection;
use Propel\Runtime\Connection\ConnectionInterface;
use Propel\Runtime\Exception\PropelException;

/**
 * Base class that represents a query for the 'amp_seller_order_version' table.
 *
 *
 *
 * @method     ChildAmpSellerOrderVersionQuery orderById($order = Criteria::ASC) Order by the id column
 * @method     ChildAmpSellerOrderVersionQuery orderByOrderId($order = Criteria::ASC) Order by the order_id column
 * @method     ChildAmpSellerOrderVersionQuery orderByAmpSellerId($order = Criteria::ASC) Order by the amp_seller_id column
 * @method     ChildAmpSellerOrderVersionQuery orderByCustomerId($order = Criteria::ASC) Order by the customer_id column
 * @method     ChildAmpSellerOrderVersionQuery orderByOrderProductId($order = Criteria::ASC) Order by the order_product_id column
 * @method     ChildAmpSellerOrderVersionQuery orderByAmpSellerOrderCounter($order = Criteria::ASC) Order by the amp_seller_order_counter column
 * @method     ChildAmpSellerOrderVersionQuery orderBySellerOrderRef($order = Criteria::ASC) Order by the seller_order_ref column
 * @method     ChildAmpSellerOrderVersionQuery orderByDiscount($order = Criteria::ASC) Order by the discount column
 * @method     ChildAmpSellerOrderVersionQuery orderByPostage($order = Criteria::ASC) Order by the postage column
 * @method     ChildAmpSellerOrderVersionQuery orderByPostageTax($order = Criteria::ASC) Order by the postage_tax column
 * @method     ChildAmpSellerOrderVersionQuery orderByStatusId($order = Criteria::ASC) Order by the status_id column
 * @method     ChildAmpSellerOrderVersionQuery orderByCreatedAt($order = Criteria::ASC) Order by the created_at column
 * @method     ChildAmpSellerOrderVersionQuery orderByUpdatedAt($order = Criteria::ASC) Order by the updated_at column
 * @method     ChildAmpSellerOrderVersionQuery orderByVersion($order = Criteria::ASC) Order by the version column
 * @method     ChildAmpSellerOrderVersionQuery orderByVersionCreatedAt($order = Criteria::ASC) Order by the version_created_at column
 * @method     ChildAmpSellerOrderVersionQuery orderByVersionCreatedBy($order = Criteria::ASC) Order by the version_created_by column
 * @method     ChildAmpSellerOrderVersionQuery orderByCustomerIdVersion($order = Criteria::ASC) Order by the customer_id_version column
 * @method     ChildAmpSellerOrderVersionQuery orderByAmpSellerIdVersion($order = Criteria::ASC) Order by the amp_seller_id_version column
 * @method     ChildAmpSellerOrderVersionQuery orderByOrderIdVersion($order = Criteria::ASC) Order by the order_id_version column
 * @method     ChildAmpSellerOrderVersionQuery orderByAmpSellerOrderDeliveryReferenceIds($order = Criteria::ASC) Order by the amp_seller_order_delivery_reference_ids column
 * @method     ChildAmpSellerOrderVersionQuery orderByAmpSellerOrderDeliveryReferenceVersions($order = Criteria::ASC) Order by the amp_seller_order_delivery_reference_versions column
 *
 * @method     ChildAmpSellerOrderVersionQuery groupById() Group by the id column
 * @method     ChildAmpSellerOrderVersionQuery groupByOrderId() Group by the order_id column
 * @method     ChildAmpSellerOrderVersionQuery groupByAmpSellerId() Group by the amp_seller_id column
 * @method     ChildAmpSellerOrderVersionQuery groupByCustomerId() Group by the customer_id column
 * @method     ChildAmpSellerOrderVersionQuery groupByOrderProductId() Group by the order_product_id column
 * @method     ChildAmpSellerOrderVersionQuery groupByAmpSellerOrderCounter() Group by the amp_seller_order_counter column
 * @method     ChildAmpSellerOrderVersionQuery groupBySellerOrderRef() Group by the seller_order_ref column
 * @method     ChildAmpSellerOrderVersionQuery groupByDiscount() Group by the discount column
 * @method     ChildAmpSellerOrderVersionQuery groupByPostage() Group by the postage column
 * @method     ChildAmpSellerOrderVersionQuery groupByPostageTax() Group by the postage_tax column
 * @method     ChildAmpSellerOrderVersionQuery groupByStatusId() Group by the status_id column
 * @method     ChildAmpSellerOrderVersionQuery groupByCreatedAt() Group by the created_at column
 * @method     ChildAmpSellerOrderVersionQuery groupByUpdatedAt() Group by the updated_at column
 * @method     ChildAmpSellerOrderVersionQuery groupByVersion() Group by the version column
 * @method     ChildAmpSellerOrderVersionQuery groupByVersionCreatedAt() Group by the version_created_at column
 * @method     ChildAmpSellerOrderVersionQuery groupByVersionCreatedBy() Group by the version_created_by column
 * @method     ChildAmpSellerOrderVersionQuery groupByCustomerIdVersion() Group by the customer_id_version column
 * @method     ChildAmpSellerOrderVersionQuery groupByAmpSellerIdVersion() Group by the amp_seller_id_version column
 * @method     ChildAmpSellerOrderVersionQuery groupByOrderIdVersion() Group by the order_id_version column
 * @method     ChildAmpSellerOrderVersionQuery groupByAmpSellerOrderDeliveryReferenceIds() Group by the amp_seller_order_delivery_reference_ids column
 * @method     ChildAmpSellerOrderVersionQuery groupByAmpSellerOrderDeliveryReferenceVersions() Group by the amp_seller_order_delivery_reference_versions column
 *
 * @method     ChildAmpSellerOrderVersionQuery leftJoin($relation) Adds a LEFT JOIN clause to the query
 * @method     ChildAmpSellerOrderVersionQuery rightJoin($relation) Adds a RIGHT JOIN clause to the query
 * @method     ChildAmpSellerOrderVersionQuery innerJoin($relation) Adds a INNER JOIN clause to the query
 *
 * @method     ChildAmpSellerOrderVersionQuery leftJoinAmpSellerOrder($relationAlias = null) Adds a LEFT JOIN clause to the query using the AmpSellerOrder relation
 * @method     ChildAmpSellerOrderVersionQuery rightJoinAmpSellerOrder($relationAlias = null) Adds a RIGHT JOIN clause to the query using the AmpSellerOrder relation
 * @method     ChildAmpSellerOrderVersionQuery innerJoinAmpSellerOrder($relationAlias = null) Adds a INNER JOIN clause to the query using the AmpSellerOrder relation
 *
 * @method     ChildAmpSellerOrderVersion findOne(ConnectionInterface $con = null) Return the first ChildAmpSellerOrderVersion matching the query
 * @method     ChildAmpSellerOrderVersion findOneOrCreate(ConnectionInterface $con = null) Return the first ChildAmpSellerOrderVersion matching the query, or a new ChildAmpSellerOrderVersion object populated from the query conditions when no match is found
 *
 * @method     ChildAmpSellerOrderVersion findOneById(int $id) Return the first ChildAmpSellerOrderVersion filtered by the id column
 * @method     ChildAmpSellerOrderVersion findOneByOrderId(int $order_id) Return the first ChildAmpSellerOrderVersion filtered by the order_id column
 * @method     ChildAmpSellerOrderVersion findOneByAmpSellerId(int $amp_seller_id) Return the first ChildAmpSellerOrderVersion filtered by the amp_seller_id column
 * @method     ChildAmpSellerOrderVersion findOneByCustomerId(int $customer_id) Return the first ChildAmpSellerOrderVersion filtered by the customer_id column
 * @method     ChildAmpSellerOrderVersion findOneByOrderProductId(string $order_product_id) Return the first ChildAmpSellerOrderVersion filtered by the order_product_id column
 * @method     ChildAmpSellerOrderVersion findOneByAmpSellerOrderCounter(int $amp_seller_order_counter) Return the first ChildAmpSellerOrderVersion filtered by the amp_seller_order_counter column
 * @method     ChildAmpSellerOrderVersion findOneBySellerOrderRef(string $seller_order_ref) Return the first ChildAmpSellerOrderVersion filtered by the seller_order_ref column
 * @method     ChildAmpSellerOrderVersion findOneByDiscount(string $discount) Return the first ChildAmpSellerOrderVersion filtered by the discount column
 * @method     ChildAmpSellerOrderVersion findOneByPostage(string $postage) Return the first ChildAmpSellerOrderVersion filtered by the postage column
 * @method     ChildAmpSellerOrderVersion findOneByPostageTax(string $postage_tax) Return the first ChildAmpSellerOrderVersion filtered by the postage_tax column
 * @method     ChildAmpSellerOrderVersion findOneByStatusId(int $status_id) Return the first ChildAmpSellerOrderVersion filtered by the status_id column
 * @method     ChildAmpSellerOrderVersion findOneByCreatedAt(string $created_at) Return the first ChildAmpSellerOrderVersion filtered by the created_at column
 * @method     ChildAmpSellerOrderVersion findOneByUpdatedAt(string $updated_at) Return the first ChildAmpSellerOrderVersion filtered by the updated_at column
 * @method     ChildAmpSellerOrderVersion findOneByVersion(int $version) Return the first ChildAmpSellerOrderVersion filtered by the version column
 * @method     ChildAmpSellerOrderVersion findOneByVersionCreatedAt(string $version_created_at) Return the first ChildAmpSellerOrderVersion filtered by the version_created_at column
 * @method     ChildAmpSellerOrderVersion findOneByVersionCreatedBy(string $version_created_by) Return the first ChildAmpSellerOrderVersion filtered by the version_created_by column
 * @method     ChildAmpSellerOrderVersion findOneByCustomerIdVersion(int $customer_id_version) Return the first ChildAmpSellerOrderVersion filtered by the customer_id_version column
 * @method     ChildAmpSellerOrderVersion findOneByAmpSellerIdVersion(int $amp_seller_id_version) Return the first ChildAmpSellerOrderVersion filtered by the amp_seller_id_version column
 * @method     ChildAmpSellerOrderVersion findOneByOrderIdVersion(int $order_id_version) Return the first ChildAmpSellerOrderVersion filtered by the order_id_version column
 * @method     ChildAmpSellerOrderVersion findOneByAmpSellerOrderDeliveryReferenceIds(array $amp_seller_order_delivery_reference_ids) Return the first ChildAmpSellerOrderVersion filtered by the amp_seller_order_delivery_reference_ids column
 * @method     ChildAmpSellerOrderVersion findOneByAmpSellerOrderDeliveryReferenceVersions(array $amp_seller_order_delivery_reference_versions) Return the first ChildAmpSellerOrderVersion filtered by the amp_seller_order_delivery_reference_versions column
 *
 * @method     array findById(int $id) Return ChildAmpSellerOrderVersion objects filtered by the id column
 * @method     array findByOrderId(int $order_id) Return ChildAmpSellerOrderVersion objects filtered by the order_id column
 * @method     array findByAmpSellerId(int $amp_seller_id) Return ChildAmpSellerOrderVersion objects filtered by the amp_seller_id column
 * @method     array findByCustomerId(int $customer_id) Return ChildAmpSellerOrderVersion objects filtered by the customer_id column
 * @method     array findByOrderProductId(string $order_product_id) Return ChildAmpSellerOrderVersion objects filtered by the order_product_id column
 * @method     array findByAmpSellerOrderCounter(int $amp_seller_order_counter) Return ChildAmpSellerOrderVersion objects filtered by the amp_seller_order_counter column
 * @method     array findBySellerOrderRef(string $seller_order_ref) Return ChildAmpSellerOrderVersion objects filtered by the seller_order_ref column
 * @method     array findByDiscount(string $discount) Return ChildAmpSellerOrderVersion objects filtered by the discount column
 * @method     array findByPostage(string $postage) Return ChildAmpSellerOrderVersion objects filtered by the postage column
 * @method     array findByPostageTax(string $postage_tax) Return ChildAmpSellerOrderVersion objects filtered by the postage_tax column
 * @method     array findByStatusId(int $status_id) Return ChildAmpSellerOrderVersion objects filtered by the status_id column
 * @method     array findByCreatedAt(string $created_at) Return ChildAmpSellerOrderVersion objects filtered by the created_at column
 * @method     array findByUpdatedAt(string $updated_at) Return ChildAmpSellerOrderVersion objects filtered by the updated_at column
 * @method     array findByVersion(int $version) Return ChildAmpSellerOrderVersion objects filtered by the version column
 * @method     array findByVersionCreatedAt(string $version_created_at) Return ChildAmpSellerOrderVersion objects filtered by the version_created_at column
 * @method     array findByVersionCreatedBy(string $version_created_by) Return ChildAmpSellerOrderVersion objects filtered by the version_created_by column
 * @method     array findByCustomerIdVersion(int $customer_id_version) Return ChildAmpSellerOrderVersion objects filtered by the customer_id_version column
 * @method     array findByAmpSellerIdVersion(int $amp_seller_id_version) Return ChildAmpSellerOrderVersion objects filtered by the amp_seller_id_version column
 * @method     array findByOrderIdVersion(int $order_id_version) Return ChildAmpSellerOrderVersion objects filtered by the order_id_version column
 * @method     array findByAmpSellerOrderDeliveryReferenceIds(array $amp_seller_order_delivery_reference_ids) Return ChildAmpSellerOrderVersion objects filtered by the amp_seller_order_delivery_reference_ids column
 * @method     array findByAmpSellerOrderDeliveryReferenceVersions(array $amp_seller_order_delivery_reference_versions) Return ChildAmpSellerOrderVersion objects filtered by the amp_seller_order_delivery_reference_versions column
 *
 */
abstract class AmpSellerOrderVersionQuery extends ModelCriteria
{

    /**
     * Initializes internal state of \ArtabanMarketplace\Model\Base\AmpSellerOrderVersionQuery object.
     *
     * @param     string $dbName The database name
     * @param     string $modelName The phpName of a model, e.g. 'Book'
     * @param     string $modelAlias The alias for the model in this query, e.g. 'b'
     */
    public function __construct($dbName = 'thelia', $modelName = '\\ArtabanMarketplace\\Model\\AmpSellerOrderVersion', $modelAlias = null)
    {
        parent::__construct($dbName, $modelName, $modelAlias);
    }

    /**
     * Returns a new ChildAmpSellerOrderVersionQuery object.
     *
     * @param     string $modelAlias The alias of a model in the query
     * @param     Criteria $criteria Optional Criteria to build the query from
     *
     * @return ChildAmpSellerOrderVersionQuery
     */
    public static function create($modelAlias = null, $criteria = null)
    {
        if ($criteria instanceof \ArtabanMarketplace\Model\AmpSellerOrderVersionQuery) {
            return $criteria;
        }
        $query = new \ArtabanMarketplace\Model\AmpSellerOrderVersionQuery();
        if (null !== $modelAlias) {
            $query->setModelAlias($modelAlias);
        }
        if ($criteria instanceof Criteria) {
            $query->mergeWith($criteria);
        }

        return $query;
    }

    /**
     * Find object by primary key.
     * Propel uses the instance pool to skip the database if the object exists.
     * Go fast if the query is untouched.
     *
     * <code>
     * $obj = $c->findPk(array(12, 34), $con);
     * </code>
     *
     * @param array[$id, $version] $key Primary key to use for the query
     * @param ConnectionInterface $con an optional connection object
     *
     * @return ChildAmpSellerOrderVersion|array|mixed the result, formatted by the current formatter
     */
    public function findPk($key, $con = null)
    {
        if ($key === null) {
            return null;
        }
        if ((null !== ($obj = AmpSellerOrderVersionTableMap::getInstanceFromPool(serialize(array((string) $key[0], (string) $key[1]))))) && !$this->formatter) {
            // the object is already in the instance pool
            return $obj;
        }
        if ($con === null) {
            $con = Propel::getServiceContainer()->getReadConnection(AmpSellerOrderVersionTableMap::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);
        } else {
            return $this->findPkSimple($key, $con);
        }
    }

    /**
     * Find object by primary key using raw SQL to go fast.
     * Bypass doSelect() and the object formatter by using generated code.
     *
     * @param     mixed $key Primary key to use for the query
     * @param     ConnectionInterface $con A connection object
     *
     * @return   ChildAmpSellerOrderVersion A model object, or null if the key is not found
     */
    protected function findPkSimple($key, $con)
    {
        $sql = 'SELECT ID, ORDER_ID, AMP_SELLER_ID, CUSTOMER_ID, ORDER_PRODUCT_ID, AMP_SELLER_ORDER_COUNTER, SELLER_ORDER_REF, DISCOUNT, POSTAGE, POSTAGE_TAX, STATUS_ID, CREATED_AT, UPDATED_AT, VERSION, VERSION_CREATED_AT, VERSION_CREATED_BY, CUSTOMER_ID_VERSION, AMP_SELLER_ID_VERSION, ORDER_ID_VERSION, AMP_SELLER_ORDER_DELIVERY_REFERENCE_IDS, AMP_SELLER_ORDER_DELIVERY_REFERENCE_VERSIONS FROM amp_seller_order_version WHERE ID = :p0 AND VERSION = :p1';
        try {
            $stmt = $con->prepare($sql);
            $stmt->bindValue(':p0', $key[0], PDO::PARAM_INT);
            $stmt->bindValue(':p1', $key[1], 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)) {
            $obj = new ChildAmpSellerOrderVersion();
            $obj->hydrate($row);
            AmpSellerOrderVersionTableMap::addInstanceToPool($obj, serialize(array((string) $key[0], (string) $key[1])));
        }
        $stmt->closeCursor();

        return $obj;
    }

    /**
     * Find object by primary key.
     *
     * @param     mixed $key Primary key to use for the query
     * @param     ConnectionInterface $con A connection object
     *
     * @return ChildAmpSellerOrderVersion|array|mixed the result, formatted by the current formatter
     */
    protected function findPkComplex($key, $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);
    }

    /**
     * Find objects by primary key
     * <code>
     * $objs = $c->findPks(array(array(12, 56), array(832, 123), array(123, 456)), $con);
     * </code>
     * @param     array $keys Primary keys to use for the query
     * @param     ConnectionInterface $con an optional connection object
     *
     * @return ObjectCollection|array|mixed the list of results, formatted by the current formatter
     */
    public function findPks($keys, $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);
    }

    /**
     * Filter the query by primary key
     *
     * @param     mixed $key Primary key to use for the query
     *
     * @return ChildAmpSellerOrderVersionQuery The current query, for fluid interface
     */
    public function filterByPrimaryKey($key)
    {
        $this->addUsingAlias(AmpSellerOrderVersionTableMap::ID, $key[0], Criteria::EQUAL);
        $this->addUsingAlias(AmpSellerOrderVersionTableMap::VERSION, $key[1], Criteria::EQUAL);

        return $this;
    }

    /**
     * Filter the query by a list of primary keys
     *
     * @param     array $keys The list of primary key to use for the query
     *
     * @return ChildAmpSellerOrderVersionQuery The current query, for fluid interface
     */
    public function filterByPrimaryKeys($keys)
    {
        if (empty($keys)) {
            return $this->add(null, '1<>1', Criteria::CUSTOM);
        }
        foreach ($keys as $key) {
            $cton0 = $this->getNewCriterion(AmpSellerOrderVersionTableMap::ID, $key[0], Criteria::EQUAL);
            $cton1 = $this->getNewCriterion(AmpSellerOrderVersionTableMap::VERSION, $key[1], Criteria::EQUAL);
            $cton0->addAnd($cton1);
            $this->addOr($cton0);
        }

        return $this;
    }

    /**
     * Filter the query on the id column
     *
     * Example usage:
     * <code>
     * $query->filterById(1234); // WHERE id = 1234
     * $query->filterById(array(12, 34)); // WHERE id IN (12, 34)
     * $query->filterById(array('min' => 12)); // WHERE id > 12
     * </code>
     *
     * @see       filterByAmpSellerOrder()
     *
     * @param     mixed $id The value to use as filter.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return ChildAmpSellerOrderVersionQuery The current query, for fluid interface
     */
    public function filterById($id = null, $comparison = null)
    {
        if (is_array($id)) {
            $useMinMax = false;
            if (isset($id['min'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::ID, $id['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($id['max'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::ID, $id['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(AmpSellerOrderVersionTableMap::ID, $id, $comparison);
    }

    /**
     * Filter the query on the order_id column
     *
     * Example usage:
     * <code>
     * $query->filterByOrderId(1234); // WHERE order_id = 1234
     * $query->filterByOrderId(array(12, 34)); // WHERE order_id IN (12, 34)
     * $query->filterByOrderId(array('min' => 12)); // WHERE order_id > 12
     * </code>
     *
     * @param     mixed $orderId The value to use as filter.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return ChildAmpSellerOrderVersionQuery The current query, for fluid interface
     */
    public function filterByOrderId($orderId = null, $comparison = null)
    {
        if (is_array($orderId)) {
            $useMinMax = false;
            if (isset($orderId['min'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::ORDER_ID, $orderId['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($orderId['max'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::ORDER_ID, $orderId['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(AmpSellerOrderVersionTableMap::ORDER_ID, $orderId, $comparison);
    }

    /**
     * Filter the query on the amp_seller_id column
     *
     * Example usage:
     * <code>
     * $query->filterByAmpSellerId(1234); // WHERE amp_seller_id = 1234
     * $query->filterByAmpSellerId(array(12, 34)); // WHERE amp_seller_id IN (12, 34)
     * $query->filterByAmpSellerId(array('min' => 12)); // WHERE amp_seller_id > 12
     * </code>
     *
     * @param     mixed $ampSellerId The value to use as filter.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return ChildAmpSellerOrderVersionQuery The current query, for fluid interface
     */
    public function filterByAmpSellerId($ampSellerId = null, $comparison = null)
    {
        if (is_array($ampSellerId)) {
            $useMinMax = false;
            if (isset($ampSellerId['min'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::AMP_SELLER_ID, $ampSellerId['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($ampSellerId['max'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::AMP_SELLER_ID, $ampSellerId['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(AmpSellerOrderVersionTableMap::AMP_SELLER_ID, $ampSellerId, $comparison);
    }

    /**
     * Filter the query on the customer_id column
     *
     * Example usage:
     * <code>
     * $query->filterByCustomerId(1234); // WHERE customer_id = 1234
     * $query->filterByCustomerId(array(12, 34)); // WHERE customer_id IN (12, 34)
     * $query->filterByCustomerId(array('min' => 12)); // WHERE customer_id > 12
     * </code>
     *
     * @param     mixed $customerId The value to use as filter.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return ChildAmpSellerOrderVersionQuery The current query, for fluid interface
     */
    public function filterByCustomerId($customerId = null, $comparison = null)
    {
        if (is_array($customerId)) {
            $useMinMax = false;
            if (isset($customerId['min'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::CUSTOMER_ID, $customerId['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($customerId['max'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::CUSTOMER_ID, $customerId['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(AmpSellerOrderVersionTableMap::CUSTOMER_ID, $customerId, $comparison);
    }

    /**
     * Filter the query on the order_product_id column
     *
     * Example usage:
     * <code>
     * $query->filterByOrderProductId('fooValue');   // WHERE order_product_id = 'fooValue'
     * $query->filterByOrderProductId('%fooValue%'); // WHERE order_product_id LIKE '%fooValue%'
     * </code>
     *
     * @param     string $orderProductId The value to use as filter.
     *              Accepts wildcards (* and % trigger a LIKE)
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return ChildAmpSellerOrderVersionQuery The current query, for fluid interface
     */
    public function filterByOrderProductId($orderProductId = null, $comparison = null)
    {
        if (null === $comparison) {
            if (is_array($orderProductId)) {
                $comparison = Criteria::IN;
            } elseif (preg_match('/[\%\*]/', $orderProductId)) {
                $orderProductId = str_replace('*', '%', $orderProductId);
                $comparison = Criteria::LIKE;
            }
        }

        return $this->addUsingAlias(AmpSellerOrderVersionTableMap::ORDER_PRODUCT_ID, $orderProductId, $comparison);
    }

    /**
     * Filter the query on the amp_seller_order_counter column
     *
     * Example usage:
     * <code>
     * $query->filterByAmpSellerOrderCounter(1234); // WHERE amp_seller_order_counter = 1234
     * $query->filterByAmpSellerOrderCounter(array(12, 34)); // WHERE amp_seller_order_counter IN (12, 34)
     * $query->filterByAmpSellerOrderCounter(array('min' => 12)); // WHERE amp_seller_order_counter > 12
     * </code>
     *
     * @param     mixed $ampSellerOrderCounter The value to use as filter.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return ChildAmpSellerOrderVersionQuery The current query, for fluid interface
     */
    public function filterByAmpSellerOrderCounter($ampSellerOrderCounter = null, $comparison = null)
    {
        if (is_array($ampSellerOrderCounter)) {
            $useMinMax = false;
            if (isset($ampSellerOrderCounter['min'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::AMP_SELLER_ORDER_COUNTER, $ampSellerOrderCounter['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($ampSellerOrderCounter['max'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::AMP_SELLER_ORDER_COUNTER, $ampSellerOrderCounter['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(AmpSellerOrderVersionTableMap::AMP_SELLER_ORDER_COUNTER, $ampSellerOrderCounter, $comparison);
    }

    /**
     * Filter the query on the seller_order_ref column
     *
     * Example usage:
     * <code>
     * $query->filterBySellerOrderRef('fooValue');   // WHERE seller_order_ref = 'fooValue'
     * $query->filterBySellerOrderRef('%fooValue%'); // WHERE seller_order_ref LIKE '%fooValue%'
     * </code>
     *
     * @param     string $sellerOrderRef The value to use as filter.
     *              Accepts wildcards (* and % trigger a LIKE)
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return ChildAmpSellerOrderVersionQuery The current query, for fluid interface
     */
    public function filterBySellerOrderRef($sellerOrderRef = null, $comparison = null)
    {
        if (null === $comparison) {
            if (is_array($sellerOrderRef)) {
                $comparison = Criteria::IN;
            } elseif (preg_match('/[\%\*]/', $sellerOrderRef)) {
                $sellerOrderRef = str_replace('*', '%', $sellerOrderRef);
                $comparison = Criteria::LIKE;
            }
        }

        return $this->addUsingAlias(AmpSellerOrderVersionTableMap::SELLER_ORDER_REF, $sellerOrderRef, $comparison);
    }

    /**
     * Filter the query on the discount column
     *
     * Example usage:
     * <code>
     * $query->filterByDiscount(1234); // WHERE discount = 1234
     * $query->filterByDiscount(array(12, 34)); // WHERE discount IN (12, 34)
     * $query->filterByDiscount(array('min' => 12)); // WHERE discount > 12
     * </code>
     *
     * @param     mixed $discount The value to use as filter.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return ChildAmpSellerOrderVersionQuery The current query, for fluid interface
     */
    public function filterByDiscount($discount = null, $comparison = null)
    {
        if (is_array($discount)) {
            $useMinMax = false;
            if (isset($discount['min'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::DISCOUNT, $discount['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($discount['max'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::DISCOUNT, $discount['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(AmpSellerOrderVersionTableMap::DISCOUNT, $discount, $comparison);
    }

    /**
     * Filter the query on the postage column
     *
     * Example usage:
     * <code>
     * $query->filterByPostage(1234); // WHERE postage = 1234
     * $query->filterByPostage(array(12, 34)); // WHERE postage IN (12, 34)
     * $query->filterByPostage(array('min' => 12)); // WHERE postage > 12
     * </code>
     *
     * @param     mixed $postage The value to use as filter.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return ChildAmpSellerOrderVersionQuery The current query, for fluid interface
     */
    public function filterByPostage($postage = null, $comparison = null)
    {
        if (is_array($postage)) {
            $useMinMax = false;
            if (isset($postage['min'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::POSTAGE, $postage['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($postage['max'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::POSTAGE, $postage['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(AmpSellerOrderVersionTableMap::POSTAGE, $postage, $comparison);
    }

    /**
     * Filter the query on the postage_tax column
     *
     * Example usage:
     * <code>
     * $query->filterByPostageTax(1234); // WHERE postage_tax = 1234
     * $query->filterByPostageTax(array(12, 34)); // WHERE postage_tax IN (12, 34)
     * $query->filterByPostageTax(array('min' => 12)); // WHERE postage_tax > 12
     * </code>
     *
     * @param     mixed $postageTax The value to use as filter.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return ChildAmpSellerOrderVersionQuery The current query, for fluid interface
     */
    public function filterByPostageTax($postageTax = null, $comparison = null)
    {
        if (is_array($postageTax)) {
            $useMinMax = false;
            if (isset($postageTax['min'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::POSTAGE_TAX, $postageTax['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($postageTax['max'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::POSTAGE_TAX, $postageTax['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(AmpSellerOrderVersionTableMap::POSTAGE_TAX, $postageTax, $comparison);
    }

    /**
     * Filter the query on the status_id column
     *
     * Example usage:
     * <code>
     * $query->filterByStatusId(1234); // WHERE status_id = 1234
     * $query->filterByStatusId(array(12, 34)); // WHERE status_id IN (12, 34)
     * $query->filterByStatusId(array('min' => 12)); // WHERE status_id > 12
     * </code>
     *
     * @param     mixed $statusId The value to use as filter.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return ChildAmpSellerOrderVersionQuery The current query, for fluid interface
     */
    public function filterByStatusId($statusId = null, $comparison = null)
    {
        if (is_array($statusId)) {
            $useMinMax = false;
            if (isset($statusId['min'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::STATUS_ID, $statusId['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($statusId['max'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::STATUS_ID, $statusId['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(AmpSellerOrderVersionTableMap::STATUS_ID, $statusId, $comparison);
    }

    /**
     * Filter the query on the created_at column
     *
     * Example usage:
     * <code>
     * $query->filterByCreatedAt('2011-03-14'); // WHERE created_at = '2011-03-14'
     * $query->filterByCreatedAt('now'); // WHERE created_at = '2011-03-14'
     * $query->filterByCreatedAt(array('max' => 'yesterday')); // WHERE created_at > '2011-03-13'
     * </code>
     *
     * @param     mixed $createdAt The value to use as filter.
     *              Values can be integers (unix timestamps), DateTime objects, or strings.
     *              Empty strings are treated as NULL.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return ChildAmpSellerOrderVersionQuery The current query, for fluid interface
     */
    public function filterByCreatedAt($createdAt = null, $comparison = null)
    {
        if (is_array($createdAt)) {
            $useMinMax = false;
            if (isset($createdAt['min'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::CREATED_AT, $createdAt['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($createdAt['max'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::CREATED_AT, $createdAt['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(AmpSellerOrderVersionTableMap::CREATED_AT, $createdAt, $comparison);
    }

    /**
     * Filter the query on the updated_at column
     *
     * Example usage:
     * <code>
     * $query->filterByUpdatedAt('2011-03-14'); // WHERE updated_at = '2011-03-14'
     * $query->filterByUpdatedAt('now'); // WHERE updated_at = '2011-03-14'
     * $query->filterByUpdatedAt(array('max' => 'yesterday')); // WHERE updated_at > '2011-03-13'
     * </code>
     *
     * @param     mixed $updatedAt The value to use as filter.
     *              Values can be integers (unix timestamps), DateTime objects, or strings.
     *              Empty strings are treated as NULL.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return ChildAmpSellerOrderVersionQuery The current query, for fluid interface
     */
    public function filterByUpdatedAt($updatedAt = null, $comparison = null)
    {
        if (is_array($updatedAt)) {
            $useMinMax = false;
            if (isset($updatedAt['min'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::UPDATED_AT, $updatedAt['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($updatedAt['max'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::UPDATED_AT, $updatedAt['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(AmpSellerOrderVersionTableMap::UPDATED_AT, $updatedAt, $comparison);
    }

    /**
     * Filter the query on the version column
     *
     * Example usage:
     * <code>
     * $query->filterByVersion(1234); // WHERE version = 1234
     * $query->filterByVersion(array(12, 34)); // WHERE version IN (12, 34)
     * $query->filterByVersion(array('min' => 12)); // WHERE version > 12
     * </code>
     *
     * @param     mixed $version The value to use as filter.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return ChildAmpSellerOrderVersionQuery The current query, for fluid interface
     */
    public function filterByVersion($version = null, $comparison = null)
    {
        if (is_array($version)) {
            $useMinMax = false;
            if (isset($version['min'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::VERSION, $version['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($version['max'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::VERSION, $version['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(AmpSellerOrderVersionTableMap::VERSION, $version, $comparison);
    }

    /**
     * Filter the query on the version_created_at column
     *
     * Example usage:
     * <code>
     * $query->filterByVersionCreatedAt('2011-03-14'); // WHERE version_created_at = '2011-03-14'
     * $query->filterByVersionCreatedAt('now'); // WHERE version_created_at = '2011-03-14'
     * $query->filterByVersionCreatedAt(array('max' => 'yesterday')); // WHERE version_created_at > '2011-03-13'
     * </code>
     *
     * @param     mixed $versionCreatedAt The value to use as filter.
     *              Values can be integers (unix timestamps), DateTime objects, or strings.
     *              Empty strings are treated as NULL.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return ChildAmpSellerOrderVersionQuery The current query, for fluid interface
     */
    public function filterByVersionCreatedAt($versionCreatedAt = null, $comparison = null)
    {
        if (is_array($versionCreatedAt)) {
            $useMinMax = false;
            if (isset($versionCreatedAt['min'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::VERSION_CREATED_AT, $versionCreatedAt['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($versionCreatedAt['max'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::VERSION_CREATED_AT, $versionCreatedAt['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(AmpSellerOrderVersionTableMap::VERSION_CREATED_AT, $versionCreatedAt, $comparison);
    }

    /**
     * Filter the query on the version_created_by column
     *
     * Example usage:
     * <code>
     * $query->filterByVersionCreatedBy('fooValue');   // WHERE version_created_by = 'fooValue'
     * $query->filterByVersionCreatedBy('%fooValue%'); // WHERE version_created_by LIKE '%fooValue%'
     * </code>
     *
     * @param     string $versionCreatedBy The value to use as filter.
     *              Accepts wildcards (* and % trigger a LIKE)
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return ChildAmpSellerOrderVersionQuery The current query, for fluid interface
     */
    public function filterByVersionCreatedBy($versionCreatedBy = null, $comparison = null)
    {
        if (null === $comparison) {
            if (is_array($versionCreatedBy)) {
                $comparison = Criteria::IN;
            } elseif (preg_match('/[\%\*]/', $versionCreatedBy)) {
                $versionCreatedBy = str_replace('*', '%', $versionCreatedBy);
                $comparison = Criteria::LIKE;
            }
        }

        return $this->addUsingAlias(AmpSellerOrderVersionTableMap::VERSION_CREATED_BY, $versionCreatedBy, $comparison);
    }

    /**
     * Filter the query on the customer_id_version column
     *
     * Example usage:
     * <code>
     * $query->filterByCustomerIdVersion(1234); // WHERE customer_id_version = 1234
     * $query->filterByCustomerIdVersion(array(12, 34)); // WHERE customer_id_version IN (12, 34)
     * $query->filterByCustomerIdVersion(array('min' => 12)); // WHERE customer_id_version > 12
     * </code>
     *
     * @param     mixed $customerIdVersion The value to use as filter.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return ChildAmpSellerOrderVersionQuery The current query, for fluid interface
     */
    public function filterByCustomerIdVersion($customerIdVersion = null, $comparison = null)
    {
        if (is_array($customerIdVersion)) {
            $useMinMax = false;
            if (isset($customerIdVersion['min'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::CUSTOMER_ID_VERSION, $customerIdVersion['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($customerIdVersion['max'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::CUSTOMER_ID_VERSION, $customerIdVersion['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(AmpSellerOrderVersionTableMap::CUSTOMER_ID_VERSION, $customerIdVersion, $comparison);
    }

    /**
     * Filter the query on the amp_seller_id_version column
     *
     * Example usage:
     * <code>
     * $query->filterByAmpSellerIdVersion(1234); // WHERE amp_seller_id_version = 1234
     * $query->filterByAmpSellerIdVersion(array(12, 34)); // WHERE amp_seller_id_version IN (12, 34)
     * $query->filterByAmpSellerIdVersion(array('min' => 12)); // WHERE amp_seller_id_version > 12
     * </code>
     *
     * @param     mixed $ampSellerIdVersion The value to use as filter.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return ChildAmpSellerOrderVersionQuery The current query, for fluid interface
     */
    public function filterByAmpSellerIdVersion($ampSellerIdVersion = null, $comparison = null)
    {
        if (is_array($ampSellerIdVersion)) {
            $useMinMax = false;
            if (isset($ampSellerIdVersion['min'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::AMP_SELLER_ID_VERSION, $ampSellerIdVersion['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($ampSellerIdVersion['max'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::AMP_SELLER_ID_VERSION, $ampSellerIdVersion['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(AmpSellerOrderVersionTableMap::AMP_SELLER_ID_VERSION, $ampSellerIdVersion, $comparison);
    }

    /**
     * Filter the query on the order_id_version column
     *
     * Example usage:
     * <code>
     * $query->filterByOrderIdVersion(1234); // WHERE order_id_version = 1234
     * $query->filterByOrderIdVersion(array(12, 34)); // WHERE order_id_version IN (12, 34)
     * $query->filterByOrderIdVersion(array('min' => 12)); // WHERE order_id_version > 12
     * </code>
     *
     * @param     mixed $orderIdVersion The value to use as filter.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return ChildAmpSellerOrderVersionQuery The current query, for fluid interface
     */
    public function filterByOrderIdVersion($orderIdVersion = null, $comparison = null)
    {
        if (is_array($orderIdVersion)) {
            $useMinMax = false;
            if (isset($orderIdVersion['min'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::ORDER_ID_VERSION, $orderIdVersion['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($orderIdVersion['max'])) {
                $this->addUsingAlias(AmpSellerOrderVersionTableMap::ORDER_ID_VERSION, $orderIdVersion['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(AmpSellerOrderVersionTableMap::ORDER_ID_VERSION, $orderIdVersion, $comparison);
    }

    /**
     * Filter the query on the amp_seller_order_delivery_reference_ids column
     *
     * @param     array $ampSellerOrderDeliveryReferenceIds The values to use as filter.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return ChildAmpSellerOrderVersionQuery The current query, for fluid interface
     */
    public function filterByAmpSellerOrderDeliveryReferenceIds($ampSellerOrderDeliveryReferenceIds = null, $comparison = null)
    {
        $key = $this->getAliasedColName(AmpSellerOrderVersionTableMap::AMP_SELLER_ORDER_DELIVERY_REFERENCE_IDS);
        if (null === $comparison || $comparison == Criteria::CONTAINS_ALL) {
            foreach ($ampSellerOrderDeliveryReferenceIds as $value) {
                $value = '%| ' . $value . ' |%';
                if ($this->containsKey($key)) {
                    $this->addAnd($key, $value, Criteria::LIKE);
                } else {
                    $this->add($key, $value, Criteria::LIKE);
                }
            }

            return $this;
        } elseif ($comparison == Criteria::CONTAINS_SOME) {
            foreach ($ampSellerOrderDeliveryReferenceIds as $value) {
                $value = '%| ' . $value . ' |%';
                if ($this->containsKey($key)) {
                    $this->addOr($key, $value, Criteria::LIKE);
                } else {
                    $this->add($key, $value, Criteria::LIKE);
                }
            }

            return $this;
        } elseif ($comparison == Criteria::CONTAINS_NONE) {
            foreach ($ampSellerOrderDeliveryReferenceIds as $value) {
                $value = '%| ' . $value . ' |%';
                if ($this->containsKey($key)) {
                    $this->addAnd($key, $value, Criteria::NOT_LIKE);
                } else {
                    $this->add($key, $value, Criteria::NOT_LIKE);
                }
            }
            $this->addOr($key, null, Criteria::ISNULL);

            return $this;
        }

        return $this->addUsingAlias(AmpSellerOrderVersionTableMap::AMP_SELLER_ORDER_DELIVERY_REFERENCE_IDS, $ampSellerOrderDeliveryReferenceIds, $comparison);
    }

    /**
     * Filter the query on the amp_seller_order_delivery_reference_ids column
     * @param     mixed $ampSellerOrderDeliveryReferenceIds The value to use as filter
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::CONTAINS_ALL
     *
     * @return ChildAmpSellerOrderVersionQuery The current query, for fluid interface
     */
    public function filterByAmpSellerOrderDeliveryReferenceId($ampSellerOrderDeliveryReferenceIds = null, $comparison = null)
    {
        if (null === $comparison || $comparison == Criteria::CONTAINS_ALL) {
            if (is_scalar($ampSellerOrderDeliveryReferenceIds)) {
                $ampSellerOrderDeliveryReferenceIds = '%| ' . $ampSellerOrderDeliveryReferenceIds . ' |%';
                $comparison = Criteria::LIKE;
            }
        } elseif ($comparison == Criteria::CONTAINS_NONE) {
            $ampSellerOrderDeliveryReferenceIds = '%| ' . $ampSellerOrderDeliveryReferenceIds . ' |%';
            $comparison = Criteria::NOT_LIKE;
            $key = $this->getAliasedColName(AmpSellerOrderVersionTableMap::AMP_SELLER_ORDER_DELIVERY_REFERENCE_IDS);
            if ($this->containsKey($key)) {
                $this->addAnd($key, $ampSellerOrderDeliveryReferenceIds, $comparison);
            } else {
                $this->addAnd($key, $ampSellerOrderDeliveryReferenceIds, $comparison);
            }
            $this->addOr($key, null, Criteria::ISNULL);

            return $this;
        }

        return $this->addUsingAlias(AmpSellerOrderVersionTableMap::AMP_SELLER_ORDER_DELIVERY_REFERENCE_IDS, $ampSellerOrderDeliveryReferenceIds, $comparison);
    }

    /**
     * Filter the query on the amp_seller_order_delivery_reference_versions column
     *
     * @param     array $ampSellerOrderDeliveryReferenceVersions The values to use as filter.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return ChildAmpSellerOrderVersionQuery The current query, for fluid interface
     */
    public function filterByAmpSellerOrderDeliveryReferenceVersions($ampSellerOrderDeliveryReferenceVersions = null, $comparison = null)
    {
        $key = $this->getAliasedColName(AmpSellerOrderVersionTableMap::AMP_SELLER_ORDER_DELIVERY_REFERENCE_VERSIONS);
        if (null === $comparison || $comparison == Criteria::CONTAINS_ALL) {
            foreach ($ampSellerOrderDeliveryReferenceVersions as $value) {
                $value = '%| ' . $value . ' |%';
                if ($this->containsKey($key)) {
                    $this->addAnd($key, $value, Criteria::LIKE);
                } else {
                    $this->add($key, $value, Criteria::LIKE);
                }
            }

            return $this;
        } elseif ($comparison == Criteria::CONTAINS_SOME) {
            foreach ($ampSellerOrderDeliveryReferenceVersions as $value) {
                $value = '%| ' . $value . ' |%';
                if ($this->containsKey($key)) {
                    $this->addOr($key, $value, Criteria::LIKE);
                } else {
                    $this->add($key, $value, Criteria::LIKE);
                }
            }

            return $this;
        } elseif ($comparison == Criteria::CONTAINS_NONE) {
            foreach ($ampSellerOrderDeliveryReferenceVersions as $value) {
                $value = '%| ' . $value . ' |%';
                if ($this->containsKey($key)) {
                    $this->addAnd($key, $value, Criteria::NOT_LIKE);
                } else {
                    $this->add($key, $value, Criteria::NOT_LIKE);
                }
            }
            $this->addOr($key, null, Criteria::ISNULL);

            return $this;
        }

        return $this->addUsingAlias(AmpSellerOrderVersionTableMap::AMP_SELLER_ORDER_DELIVERY_REFERENCE_VERSIONS, $ampSellerOrderDeliveryReferenceVersions, $comparison);
    }

    /**
     * Filter the query on the amp_seller_order_delivery_reference_versions column
     * @param     mixed $ampSellerOrderDeliveryReferenceVersions The value to use as filter
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::CONTAINS_ALL
     *
     * @return ChildAmpSellerOrderVersionQuery The current query, for fluid interface
     */
    public function filterByAmpSellerOrderDeliveryReferenceVersion($ampSellerOrderDeliveryReferenceVersions = null, $comparison = null)
    {
        if (null === $comparison || $comparison == Criteria::CONTAINS_ALL) {
            if (is_scalar($ampSellerOrderDeliveryReferenceVersions)) {
                $ampSellerOrderDeliveryReferenceVersions = '%| ' . $ampSellerOrderDeliveryReferenceVersions . ' |%';
                $comparison = Criteria::LIKE;
            }
        } elseif ($comparison == Criteria::CONTAINS_NONE) {
            $ampSellerOrderDeliveryReferenceVersions = '%| ' . $ampSellerOrderDeliveryReferenceVersions . ' |%';
            $comparison = Criteria::NOT_LIKE;
            $key = $this->getAliasedColName(AmpSellerOrderVersionTableMap::AMP_SELLER_ORDER_DELIVERY_REFERENCE_VERSIONS);
            if ($this->containsKey($key)) {
                $this->addAnd($key, $ampSellerOrderDeliveryReferenceVersions, $comparison);
            } else {
                $this->addAnd($key, $ampSellerOrderDeliveryReferenceVersions, $comparison);
            }
            $this->addOr($key, null, Criteria::ISNULL);

            return $this;
        }

        return $this->addUsingAlias(AmpSellerOrderVersionTableMap::AMP_SELLER_ORDER_DELIVERY_REFERENCE_VERSIONS, $ampSellerOrderDeliveryReferenceVersions, $comparison);
    }

    /**
     * Filter the query by a related \ArtabanMarketplace\Model\AmpSellerOrder object
     *
     * @param \ArtabanMarketplace\Model\AmpSellerOrder|ObjectCollection $ampSellerOrder The related object(s) to use as filter
     * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return ChildAmpSellerOrderVersionQuery The current query, for fluid interface
     */
    public function filterByAmpSellerOrder($ampSellerOrder, $comparison = null)
    {
        if ($ampSellerOrder instanceof \ArtabanMarketplace\Model\AmpSellerOrder) {
            return $this
                ->addUsingAlias(AmpSellerOrderVersionTableMap::ID, $ampSellerOrder->getId(), $comparison);
        } elseif ($ampSellerOrder instanceof ObjectCollection) {
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }

            return $this
                ->addUsingAlias(AmpSellerOrderVersionTableMap::ID, $ampSellerOrder->toKeyValue('PrimaryKey', 'Id'), $comparison);
        } else {
            throw new PropelException('filterByAmpSellerOrder() only accepts arguments of type \ArtabanMarketplace\Model\AmpSellerOrder or Collection');
        }
    }

    /**
     * Adds a JOIN clause to the query using the AmpSellerOrder relation
     *
     * @param     string $relationAlias optional alias for the relation
     * @param     string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
     *
     * @return ChildAmpSellerOrderVersionQuery The current query, for fluid interface
     */
    public function joinAmpSellerOrder($relationAlias = null, $joinType = Criteria::INNER_JOIN)
    {
        $tableMap = $this->getTableMap();
        $relationMap = $tableMap->getRelation('AmpSellerOrder');

        // create a ModelJoin object for this join
        $join = new ModelJoin();
        $join->setJoinType($joinType);
        $join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
        if ($previousJoin = $this->getPreviousJoin()) {
            $join->setPreviousJoin($previousJoin);
        }

        // add the ModelJoin to the current object
        if ($relationAlias) {
            $this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
            $this->addJoinObject($join, $relationAlias);
        } else {
            $this->addJoinObject($join, 'AmpSellerOrder');
        }

        return $this;
    }

    /**
     * Use the AmpSellerOrder relation AmpSellerOrder object
     *
     * @see useQuery()
     *
     * @param     string $relationAlias optional alias for the relation,
     *                                   to be used as main alias in the secondary query
     * @param     string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
     *
     * @return   \ArtabanMarketplace\Model\AmpSellerOrderQuery A secondary query class using the current class as primary query
     */
    public function useAmpSellerOrderQuery($relationAlias = null, $joinType = Criteria::INNER_JOIN)
    {
        return $this
            ->joinAmpSellerOrder($relationAlias, $joinType)
            ->useQuery($relationAlias ? $relationAlias : 'AmpSellerOrder', '\ArtabanMarketplace\Model\AmpSellerOrderQuery');
    }

    /**
     * Exclude object from result
     *
     * @param   ChildAmpSellerOrderVersion $ampSellerOrderVersion Object to remove from the list of results
     *
     * @return ChildAmpSellerOrderVersionQuery The current query, for fluid interface
     */
    public function prune($ampSellerOrderVersion = null)
    {
        if ($ampSellerOrderVersion) {
            $this->addCond('pruneCond0', $this->getAliasedColName(AmpSellerOrderVersionTableMap::ID), $ampSellerOrderVersion->getId(), Criteria::NOT_EQUAL);
            $this->addCond('pruneCond1', $this->getAliasedColName(AmpSellerOrderVersionTableMap::VERSION), $ampSellerOrderVersion->getVersion(), Criteria::NOT_EQUAL);
            $this->combine(array('pruneCond0', 'pruneCond1'), Criteria::LOGICAL_OR);
        }

        return $this;
    }

    /**
     * Deletes all rows from the amp_seller_order_version table.
     *
     * @param ConnectionInterface $con the connection to use
     * @return int The number of affected rows (if supported by underlying database driver).
     */
    public function doDeleteAll(ConnectionInterface $con = null)
    {
        if (null === $con) {
            $con = Propel::getServiceContainer()->getWriteConnection(AmpSellerOrderVersionTableMap::DATABASE_NAME);
        }
        $affectedRows = 0; // initialize var to track total num of affected rows
        try {
            // use transaction because $criteria could contain info
            // for more than one table or we could emulating ON DELETE CASCADE, etc.
            $con->beginTransaction();
            $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).
            AmpSellerOrderVersionTableMap::clearInstancePool();
            AmpSellerOrderVersionTableMap::clearRelatedInstancePool();

            $con->commit();
        } catch (PropelException $e) {
            $con->rollBack();
            throw $e;
        }

        return $affectedRows;
    }

    /**
     * Performs a DELETE on the database, given a ChildAmpSellerOrderVersion or Criteria object OR a primary key value.
     *
     * @param mixed               $values Criteria or ChildAmpSellerOrderVersion object or primary key or array of primary keys
     *              which is used to create the DELETE statement
     * @param ConnectionInterface $con the connection to use
     * @return int The number of affected rows (if supported by underlying database driver).  This includes CASCADE-related rows
     *                if supported by native driver or if emulated using Propel.
     * @throws PropelException Any exceptions caught during processing will be
     *         rethrown wrapped into a PropelException.
     */
     public function delete(ConnectionInterface $con = null)
     {
        if (null === $con) {
            $con = Propel::getServiceContainer()->getWriteConnection(AmpSellerOrderVersionTableMap::DATABASE_NAME);
        }

        $criteria = $this;

        // Set the correct dbName
        $criteria->setDbName(AmpSellerOrderVersionTableMap::DATABASE_NAME);

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

        try {
            // use transaction because $criteria could contain info
            // for more than one table or we could emulating ON DELETE CASCADE, etc.
            $con->beginTransaction();


        AmpSellerOrderVersionTableMap::removeInstanceFromPool($criteria);

            $affectedRows += ModelCriteria::delete($con);
            AmpSellerOrderVersionTableMap::clearRelatedInstancePool();
            $con->commit();

            return $affectedRows;
        } catch (PropelException $e) {
            $con->rollBack();
            throw $e;
        }
    }

} // AmpSellerOrderVersionQuery
