package org.litesoft.orsup.selection;


// Copyright Status:
//
// All Software available from LiteSoft.org (including this file) is
// hereby released into the public domain.
//
// It is free!  As in, you may use it freely in both commercial and
// non-commercial applications, bundle it with your software
// distribution, include it on a CD-ROM, list the source code in a book,
// mirror the documentation at your own web site, or use it in any other
// way you see fit.
//
// NO Warranty!
//
// All software is provided "as is".
//
// There is ABSOLUTELY NO WARRANTY OF ANY KIND: not for the design, fitness
// (for a particular purpose), level of errors (or lack thereof), or
// applicability of this software.  The entire risk as to the quality
// and performance of this software is with you.  Should this software
// prove defective, you assume the cost of all necessary servicing, repair
// or correction.
//
// In no event unless required by applicable law or agreed to in writing
// will any party who created or may modify and/or redistribute this
// software, be liable to you for damages, including any general,
// special, incidental or consequential damages arising out of the use or
// inability to use this software (including but not limited to loss of
// data or data being rendered inaccurate or losses sustained by you or
// third parties or a failure of this software to operate with any
// other programs), even if such holder or other party has been advised
// of the possibility of such damages.
//
// NOTE: Should you discover a bug, have a recogmendation for a change, wish
// to submit modifications, or wish to add new classes/functionality,
// please email them to:
//
//        changes44@litesoft.org
//

/**
 * A Factory to generate a representation of a SQL <i>WHERE</i> clause.<p>
 *
 * Using this Factory a complex SQL <i>WHERE</i> clause can be generated.
 * The concrete extensions of <b>WhereClause</b> generated by this Factory
 * can form a <i>tree</i> that represents any arbitrarily complex expression.<p>
 *
 * If you need to create/support a specific SQL <i>WHERE</i> clause that
 * is not provided, you would need to extend this class and probably one of
 * the abstract <b>WhereClause</b> helper classes listed in <b>WhereClause</b>.<p>
 *
 * See <a href="WhereClause.html">WhereClause</a><p>
 *
 * Exceptions: All problems caught when the parameter(s) are checked (as
 * indicated/implied in the @param tags) will generate an IllegalArgumentException,
 * and means the API user has a problem.  If a NullPointerException (or some
 * others, like: ClassCastException or ArrayIndexOutOfBoundsException) is thrown,
 * it means the API developer has a problem.  Any Exception that is explicitly
 * thrown in the API, but unrelated to a parameter, will be listed in the throws
 * clause (and hopefully in the tag @throws).  These may (but probably won't) be
 * checked Exceptions.
 *
 * @author  George Smith
 * @version 1.03 02/07/02 Exception Policy, Use of IllegalArgument class.
 * @version 1.02 11/05/01 Completed? JavaDocs
 * @version 1.01 10/10/01
 * @version 1.0 10/07/01
 */

public class WhereClauseFactory
{
    /**
     * Constructor that simply instantiates this Factory.<p>
     */
    public WhereClauseFactory()
    {
    }

    /**
     * Return an <b>OR</b> SQL <i>WHERE</i> clause of two other <i>WHERE</i> clauses.<p>
     *
     * Note: If either (or both) of the two <b>WhereClause</b>s are them selves
     * <i>OR</i> <b>WhereClause</b>s then, the <b>WhereClause</b>(s) are
     * <i>merged</i> (collapsed to this new one).<p>
     *
     * @param   pWhereClause1   First of the two <i>WHERE</i> clauses (!null).
     * @param   pWhereClause2   Second of the two <i>WHERE</i> clauses (!null).<p>
     *
     * @return <b>OR</b> merged <b>WhereClause</b>s.
     */
    public WhereClause or( WhereClause pWhereClause1 , WhereClause pWhereClause2 )
    {
        return new WC_OR( pWhereClause1 , pWhereClause2 );
    }

    /**
     * Return an <b>AND</b> SQL <i>WHERE</i> clause of two other <i>WHERE</i> clauses.<p>
     *
     * Note: If either (or both) of the two <b>WhereClause</b>s are them selves
     * <i>AND</i> <b>WhereClause</b>s then, the <b>WhereClause</b>(s) are
     * <i>merged</i> (collapsed to this new one).<p>
     *
     * @param   pWhereClause1   First of the two <i>WHERE</i> clauses (!null).
     * @param   pWhereClause2   Second of the two <i>WHERE</i> clauses (!null).<p>
     *
     * @return <b>AND</b> merged <b>WhereClause</b>s.
     */
    public WhereClause and( WhereClause pWhereClause1 , WhereClause pWhereClause2 )
    {
        return new WC_AND( pWhereClause1 , pWhereClause2 );
    }

    /**
     * Return a <b>NOT</b><i>ed</i> SQL <i>WHERE</i> clause.<p>
     *
     * @param   pWhereClause The WhereClause that is to be <b>NOT</b><i>ed</i> (!null).<p>
     *
     * @return <b>NOT</b><i>ed</i> WhereClause.
     */
    public WhereClause not( WhereClause pWhereClause )
    {
        if ( !(pWhereClause instanceof WhereClauseNotable) )
            return new WC_NOT( pWhereClause );

        ((WhereClauseNotable) pWhereClause).switchNot();
        return pWhereClause;
    }

    /**
     * Create a SQL <i>WHERE</i> clause that checks that a column is
     * <i>NULL</i>.<p>
     *
     * @param   pColumnDefinition   Column Definition (!null).<p>
     *
     * @return NULL WhereClause.
     */
    public WhereClause isNull( SimpleColumnDefinition pColumnDefinition )
    {
        return new WC_IS_NULL( pColumnDefinition );
    }

    /**
     * Create a SQL <i>WHERE</i> clause that checks that a column is
     * <i>NOT NULL</i>.<p>
     *
     * @param   pColumnDefinition   Column Definition (!null).<p>
     *
     * @return NOT NULL WhereClause.<p>
     *
     * @see #not(WhereClause)
     * @see #isNull(SimpleColumnDefinition)
     */
    public WhereClause isNotNull( SimpleColumnDefinition pColumnDefinition )
    {
        return not( isNull( pColumnDefinition ) );
    }

    /**
     * Create a SQL <i>WHERE</i> clause that checks that a column is
     * <i>equal to</i> an Object value.<p>
     *
     * Note: Due to the pecular nature of Java's <i>null</i> and the SQL NULL,
     * the resulting SQL <i>WHERE</i> clause may become "IS NULL".<p>
     *
     * @param   pColumnDefinition   Column Definition (!null).
     * @param   pValue              Compare with value (!null).<p>
     *
     * @return equal to WhereClause.<p>
     *
     * @see #isNull(SimpleColumnDefinition)
     */
    public WhereClause isEqual( SimpleColumnDefinition pColumnDefinition , Object pValue )
    {
        if ( pValue == null )
            return isNull( pColumnDefinition );

        return new WC_EQUALS( pColumnDefinition , pValue );
    }

    /**
     * Create a SQL <i>WHERE</i> clause that checks that a column is
     * <i>equal to</i> an <b>int</b> value.<p>
     *
     * @param   pColumnDefinition   Column Definition (!null).
     * @param   pInt                Compare with int.<p>
     *
     * @return equal to WhereClause.<p>
     *
     * @see #isEqual(SimpleColumnDefinition,Object)
     */
    public WhereClause isEqual( SimpleColumnDefinition pColumnDefinition , int pInt )
    {
        return isEqual( pColumnDefinition , new Integer( pInt ) );
    }

    /**
     * Create a SQL <i>WHERE</i> clause that checks that a column is
     * <i>NOT equal to</i> an Object value.<p>
     *
     * Note: Due to the pecular nature of Java's <i>null</i> and the SQL NULL,
     * the resulting SQL <i>WHERE</i> clause will either be "IS NOT NULL" or
     * will <i>or</i> in an "IS NULL".<p>
     *
     * @param   pColumnDefinition   Column Definition (!null).
     * @param   pValue              Compare with value (!null).<p>
     *
     * @return NOT equal to WhereClause.<p>
     *
     * @see #not(WhereClause)
     * @see #isEqual(SimpleColumnDefinition,Object)
     * @see #isNotNull(SimpleColumnDefinition)
     * @see #isNull(SimpleColumnDefinition)
     * @see #or(WhereClause,WhereClause)
     */
    public WhereClause isNotEqual( SimpleColumnDefinition pColumnDefinition , Object pValue )
    {
        return not( isEqual( pColumnDefinition , pValue ) );
    }

    /**
     * Create a SQL <i>WHERE</i> clause that checks that a column is
     * <i>NOT equal to</i> an <b>int</b> value.<p>
     *
     * Note: Due to the pecular nature of SQL NULLs, the resulting SQL
     * <i>WHERE</i> clause will <i>or</i> in an "IS NULL".<p>
     *
     * @param   pColumnDefinition   Column Definition (!null).
     * @param   pInt                Compare with int.<p>
     *
     * @return NOT equal to WhereClause.<p>
     *
     * @see #not(WhereClause)
     * @see #isEqual(SimpleColumnDefinition,int)
     * @see #isNull(SimpleColumnDefinition)
     * @see #or(WhereClause,WhereClause)
     */
    public WhereClause isNotEqual( SimpleColumnDefinition pColumnDefinition , int pInt )
    {
        return not( isEqual( pColumnDefinition , pInt ) );
    }

    /**
     * Create a SQL <i>WHERE</i> clause that checks that a column is
     * <i>less than</i> an Object value.<p>
     *
     * @param   pColumnDefinition   Column Definition (!null).
     * @param   pValue              Compare with value (!null).<p>
     *
     * @return less than WhereClause.
     */
    public WhereClause isLessThan( SimpleColumnDefinition pColumnDefinition , Object pValue )
    {
        return new WC_LESSTHAN( pColumnDefinition , pValue );
    }

    /**
     * Create a SQL <i>WHERE</i> clause that checks that a column is
     * <i>less than</i> an <b>int</b> value.<p>
     *
     * @param   pColumnDefinition   Column Definition (!null).
     * @param   pInt                Compare with int.<p>
     *
     * @return less than to WhereClause.<p>
     *
     * @see #isLessThan(SimpleColumnDefinition,Object)
     */
    public WhereClause isLessThan( SimpleColumnDefinition pColumnDefinition , int pInt )
    {
        return isLessThan( pColumnDefinition , new Integer( pInt ) );
    }

    /**
     * Create a SQL <i>WHERE</i> clause that checks that a column is
     * <i>greater than or equal to</i> an Object value.<p>
     *
     * @param   pColumnDefinition   Column Definition (!null).
     * @param   pValue              Compare with value (!null).<p>
     *
     * @return greater than or equal to WhereClause.<p>
     *
     * @see #not(WhereClause)
     * @see #isLessThan(SimpleColumnDefinition,Object)
     */
    public WhereClause isNotLessThan( SimpleColumnDefinition pColumnDefinition , Object pValue )
    {
        return not( isLessThan( pColumnDefinition , pValue ) );
    }

    /**
     * Create a SQL <i>WHERE</i> clause that checks that a column is
     * <i>greater than or equal to</i> an <b>int</b> value.<p>
     *
     * @param   pColumnDefinition   Column Definition (!null).
     * @param   pInt                Compare with int.<p>
     *
     * @return greater than or equal to WhereClause.<p>
     *
     * @see #not(WhereClause)
     * @see #isLessThan(SimpleColumnDefinition,int)
     */
    public WhereClause isNotLessThan( SimpleColumnDefinition pColumnDefinition , int pInt )
    {
        return not( isLessThan( pColumnDefinition , pInt ) );
    }

    /**
     * Create a SQL <i>WHERE</i> clause that checks that a column is
     * <i>greater than</i> an Object value.<p>
     *
     * @param   pColumnDefinition   Column Definition (!null).
     * @param   pValue              Compare with value (!null).<p>
     *
     * @return greater than to WhereClause.
     */
    public WhereClause isGreaterThan( SimpleColumnDefinition pColumnDefinition , Object pValue )
    {
        return new WC_GREATERTHAN( pColumnDefinition , pValue );
    }

    /**
     * Create a SQL <i>WHERE</i> clause that checks that a column is
     * <i>greater than</i> an <b>int</b> value.<p>
     *
     * @param   pColumnDefinition   Column Definition (!null).
     * @param   pInt                Compare with int.<p>
     *
     * @return greater than to WhereClause.<p>
     *
     * @see #isGreaterThan(SimpleColumnDefinition,Object)
     */
    public WhereClause isGreaterThan( SimpleColumnDefinition pColumnDefinition , int pInt )
    {
        return isGreaterThan( pColumnDefinition , new Integer( pInt ) );
    }

    /**
     * Create a SQL <i>WHERE</i> clause that checks that a column is
     * <i>less than or equal to</i> an Object value.<p>
     *
     * @param   pColumnDefinition   Column Definition (!null).
     * @param   pValue              Compare with value (!null).<p>
     *
     * @return less than or equal to WhereClause.<p>
     *
     * @see #not(WhereClause)
     * @see #isGreaterThan(SimpleColumnDefinition,Object)
     */
    public WhereClause isNotGreaterThan( SimpleColumnDefinition pColumnDefinition , Object pValue )
    {
        return not( isGreaterThan( pColumnDefinition , pValue ) );
    }

    /**
     * Create a SQL <i>WHERE</i> clause that checks that a column is
     * <i>less than or equal to</i> an <b>int</b> value.<p>
     *
     * @param   pColumnDefinition   Column Definition (!null).
     * @param   pInt                Compare with int.<p>
     *
     * @return less than or equal to WhereClause.<p>
     *
     * @see #not(WhereClause)
     * @see #isGreaterThan(SimpleColumnDefinition,int)
     */
    public WhereClause isNotGreaterThan( SimpleColumnDefinition pColumnDefinition , int pInt )
    {
        return not( isGreaterThan( pColumnDefinition , pInt ) );
    }

    /**
     * Create a SQL <i>WHERE</i> clause that checks that a column is
     * <i>between</i> (INCLUSIVE) two (Object) values.<p>
     *
     * Note: if the <i>left</i> and <i>right</i> values are equal, then the
     * WhereClause is of type isEqual.<p>
     *
     * @param   pColumnDefinition   Column Definition (!null).
     * @param   pGEvalue            Greater Than or Equal (left) value (!null).
     * @param   pLEvalue            Less Than or Equal (right) value (!null).<p>
     *
     * @return <b>BETWEEN</b> (or equal) WhereClause.<p>
     *
     * @see #isEqual(SimpleColumnDefinition,Object)
     */
    public WhereClause isBetween( SimpleColumnDefinition pColumnDefinition , Object pGEvalue , Object pLEvalue )
    {
        if ( (pGEvalue == pLEvalue) || ((pGEvalue != null) && pGEvalue.equals( pLEvalue )) )
            return isEqual( pColumnDefinition , pGEvalue );

        return new WC_BETWEEN( pColumnDefinition , pGEvalue , pLEvalue );
    }

    /**
     * Create a SQL <i>WHERE</i> clause that checks that a column is
     * <i>between</i> (INCLUSIVE) two <b>int</b> values.<p>
     *
     * Note: if the <i>left</i> and <i>right</i> ints are equal, then the
     * WhereClause is of type isEqual.<p>
     *
     * @param   pColumnDefinition   Column Definition (!null).
     * @param   pGEint              Greater Than or Equal (left) value.
     * @param   pLEint              Less Than or Equal (right) value.<p>
     *
     * @return <b>BETWEEN</b> (or equal) WhereClause.<p>
     *
     * @see #isBetween(SimpleColumnDefinition,Object,Object)
     * @see #isEqual(SimpleColumnDefinition,int)
     */
    public WhereClause isBetween( SimpleColumnDefinition pColumnDefinition , int pGEint , int pLEint )
    {
        if ( pGEint == pLEint )
            return isEqual( pColumnDefinition , pGEint );

        return isBetween( pColumnDefinition , new Integer( pGEint ) , new Integer( pLEint ) );
    }

    /**
     * Create a SQL <i>WHERE</i> clause that checks that a column is Not
     * <i>between</i> (INCLUSIVE) two (Object) values.<p>
     *
     * Note: if the <i>left</i> and <i>right</i> values are equal, then the
     * WhereClause is of type isNotEqual.<p>
     *
     * @param   pColumnDefinition   Column Definition (!null).
     * @param   pGEvalue            Greater Than or Equal (left) value (!null).
     * @param   pLEvalue            Less Than or Equal (right) value (!null).<p>
     *
     * @return <b>NOT BETWEEN</b> (or not equal) WhereClause.<p>
     *
     * @see #not(WhereClause)
     * @see #isBetween(SimpleColumnDefinition,Object,Object)
     * @see #isNotEqual(SimpleColumnDefinition,Object)
     */
    public WhereClause isNotBetween( SimpleColumnDefinition pColumnDefinition , Object pGEvalue , Object pLEvalue )
    {
        return not( isBetween( pColumnDefinition , pGEvalue , pLEvalue ) );
    }

    /**
     * Create a SQL <i>WHERE</i> clause that checks that a column is Not
     * <i>between</i> (INCLUSIVE) two <b>int</b> values.<p>
     *
     * Note: if the <i>left</i> and <i>right</i> ints are equal, then the
     * WhereClause is of type isNotEqual.<p>
     *
     * @param   pColumnDefinition   Column Definition (!null).
     * @param   pGEint              Greater Than or Equal (left) value.
     * @param   pLEint              Less Than or Equal (right) value.<p>
     *
     * @return <b>NOT BETWEEN</b> (or not equal) WhereClause.<p>
     *
     * @see #not(WhereClause)
     * @see #isBetween(SimpleColumnDefinition,int,int)
     * @see #isNotEqual(SimpleColumnDefinition,int)
     */
    public WhereClause isNotBetween( SimpleColumnDefinition pColumnDefinition , int pGEint , int pLEint )
    {
        return not( isBetween( pColumnDefinition , pGEint , pLEint ) );
    }

    /**
     * Create a SQL <i>WHERE</i> clause that checks that a String column
     * <i>contains</i> a particular set of characters.<p>
     *
     * @param   pColumnDefinition   Column Definition (!null).
     * @param   pValue              String that carries the particular set of characters for checking (!null).<p>
     *
     * @return <b>LIKE</b> (any where) WhereClause.
     */
    public WhereClause contains( SimpleColumnDefinition pColumnDefinition , String pValue )
    {
        return new WC_CONTAINS( pColumnDefinition , pValue );
    }

    /**
     * Create a SQL <i>WHERE</i> clause that checks that a String column
     * does Not <i>contain</i> a particular set of characters.<p>
     *
     * @param   pColumnDefinition   Column Definition (!null).
     * @param   pValue              String that carries the particular set of characters for checking (!null).<p>
     *
     * @return <b>NOT LIKE</b> (any where) WhereClause.<p>
     *
     * @see #not(WhereClause)
     * @see #contains(SimpleColumnDefinition,String)
     */
    public WhereClause doesNotContain( SimpleColumnDefinition pColumnDefinition , String pValue )
    {
        return not( contains( pColumnDefinition , pValue ) );
    }

    /**
     * Create a SQL <i>WHERE</i> clause that checks that a String column
     * <i>Starts With</i> a particular set of characters.<p>
     *
     * @param   pColumnDefinition   Column Definition (!null).
     * @param   pValue              String that carries the particular set of characters for checking (!null).<p>
     *
     * @return <b>LIKE</b> (on front) WhereClause.
     */
    public WhereClause startsWith( SimpleColumnDefinition pColumnDefinition , String pValue )
    {
        return new WC_STARTS_WITH( pColumnDefinition , pValue );
    }

    /**
     * Create a SQL <i>WHERE</i> clause that checks that a String column
     * does Not <i>Start With</i> a particular set of characters.<p>
     *
     * @param   pColumnDefinition   Column Definition (!null).
     * @param   pValue              String that carries the particular set of characters for checking (!null).<p>
     *
     * @return <b>NOT LIKE</b> (on front) WhereClause.<p>
     *
     * @see #not(WhereClause)
     * @see #startsWith(SimpleColumnDefinition,String)
     */
    public WhereClause doesNotStartWith( SimpleColumnDefinition pColumnDefinition , String pValue )
    {
        return not( startsWith( pColumnDefinition , pValue ) );
    }

    /**
     * Create a SQL <i>WHERE</i> clause that checks that a String column
     * <i>Ends With</i> a particular set of characters.<p>
     *
     * @param   pColumnDefinition   Column Definition (!null).
     * @param   pValue              String that carries the particular set of characters for checking (!null).<p>
     *
     * @return <b>LIKE</b> (on end) WhereClause.
     */
    public WhereClause endsWith( SimpleColumnDefinition pColumnDefinition , String pValue )
    {
        return new WC_ENDS_WITH( pColumnDefinition , pValue );
    }

    /**
     * Create a SQL <i>WHERE</i> clause that checks that a String column
     * does Not <i>End With</i> a particular set of characters.<p>
     *
     * @param   pColumnDefinition   Column Definition (!null).
     * @param   pValue              String that carries the particular set of characters for checking (!null).<p>
     *
     * @return <b>NOT LIKE</b> (on end) WhereClause.<p>
     *
     * @see #not(WhereClause)
     * @see #endsWith(SimpleColumnDefinition,String)
     */
    public WhereClause doesNotEndWith( SimpleColumnDefinition pColumnDefinition , String pValue )
    {
        return not( endsWith( pColumnDefinition , pValue ) );
    }

    /**
     * Create a SQL <b>IN</b> <i>WHERE</i> clause.<p>
     *
     * Note: the Column Types of the ColumnDefinition and selected column of
     * the SingleColumnSelect MUST be equal, otherwise an IllegalArgumentException
     * is thrown.<p>
     *
     * @param   pColumnDefinition   Column Definition (!null).
     * @param   pSingleColumnSelect A single column mini-SELECT command (!null).<p>
     *
     * @return <b>IN</b> WhereClause.
     */
    public WhereClause isIn( SimpleColumnDefinition pColumnDefinition , SingleColumnSelect pSingleColumnSelect )
    {
        return new WC_IS_IN( pColumnDefinition , pSingleColumnSelect );
    }

    /**
     * Create a SQL <b>NOT IN</b> <i>WHERE</i> clause.<p>
     *
     * Note: the Column Types of the ColumnDefinition and selected column of
     * the SingleColumnSelect MUST be equal, otherwise an IllegalArgumentException
     * is thrown.<p>
     *
     * @param   pColumnDefinition   Column Definition (!null).
     * @param   pSingleColumnSelect A single column mini-SELECT command (!null).<p>
     *
     * @return <b>NOT IN</b> WhereClause.<p>
     *
     * @see #not(WhereClause)
     * @see #isIn(SimpleColumnDefinition,SingleColumnSelect)
     */
    public WhereClause isNotIn( SimpleColumnDefinition pColumnDefinition , SingleColumnSelect pSingleColumnSelect )
    {
        return not( isIn( pColumnDefinition , pSingleColumnSelect ) );
    }

    // static inner classes to "leverage" the automatic namespacing...

    private static class WC_OR extends AbstractWhereClauseAssociativeList
    {
        WC_OR( WhereClause pWhereClause1 , WhereClause pWhereClause2 )
        {
            super( WhereClause.OR , "OR" , "OR" , pWhereClause1 , pWhereClause2 );
        }
    }

    private static class WC_AND extends AbstractWhereClauseAssociativeList
    {
        WC_AND( WhereClause pWhereClause1 , WhereClause pWhereClause2 )
        {
            super( WhereClause.AND , "AND" , "AND" , pWhereClause1 , pWhereClause2 );
        }
    }

    private static class WC_NOT extends AbstractWhereClauseWrapper
    {
        WC_NOT( WhereClause pWrappedWhereClause )
        {
            super( WhereClause.NOT , "NOT" , "NOT" , pWrappedWhereClause );
        }
    }

    private static class WC_IS_NULL extends AbstractWhereClauseColumnReference
    {
        WC_IS_NULL( SimpleColumnDefinition pColumnDefinition )
        {
            super( WhereClause.IS_NULL , pColumnDefinition );
        }

        protected void toStringHelper( StringBuffer pSB )
        {
            toStringColumnReference( pSB );
            pSB.append( isNot() ? " != null" : " == null" );
        }

        protected void toSqlHelper( StringBuffer pSB )
        {
            toSqlColumnReference( pSB );
            pSB.append( isNot() ? " IS NOT NULL" : " IS NULL" );
        }
    }

    private static class WC_EQUALS extends AbstractWhereClauseColumnAndValue
    {
        WC_EQUALS( SimpleColumnDefinition pColumnDefinition , Object pValue )
        {
            super( WhereClause.EQUALS , pColumnDefinition ,
                   "==" , "=" , // String , SQL
                   "!=" , "<>" , // String , SQL
                   pValue );
        }

        protected void toSqlHelper( StringBuffer pSB )
        {
            if ( !isNot() ) // Regular
                super.toSqlHelper( pSB );
            else
            {
                pSB.append( '(' );
                super.toSqlHelper( pSB );
                pSB.append( ") OR (" );
                toSqlColumnReference( pSB );
                pSB.append( " IS NULL)" );
            }
        }

    }

    private static class WC_LESSTHAN extends AbstractWhereClauseColumnAndValue
    {
        WC_LESSTHAN( SimpleColumnDefinition pColumnDefinition , Object pValue )
        {
            super( WhereClause.LESSTHAN , pColumnDefinition ,
                   "<" , "<" , // String , SQL
                   ">=" , ">=" , // String , SQL
                   pValue );
        }
    }

    private static class WC_GREATERTHAN extends AbstractWhereClauseColumnAndValue
    {
        WC_GREATERTHAN( SimpleColumnDefinition pColumnDefinition , Object pValue )
        {
            super( WhereClause.GREATERTHAN , pColumnDefinition ,
                   ">" , ">" , // String , SQL
                   "<=" , "<=" , // String , SQL
                   pValue );
        }
    }

    private static class WC_BETWEEN extends AbstractWhereClauseColumnAndTwoValues
    {
        WC_BETWEEN( SimpleColumnDefinition pColumnDefinition , Object pLeftValue , Object pRightValue )
        {
            super( WhereClause.BETWEEN , pColumnDefinition , pLeftValue , pRightValue );
        }

        protected void toStringHelper( StringBuffer pSB )
        {
            if ( !isNot() )
                cuteStringHelper( pSB );
            else
            {
                pSB.append( "NOT (" );
                cuteStringHelper( pSB );
                pSB.append( ')' );
            }
        }

        private void cuteStringHelper( StringBuffer pSB )
        {
            WhereClauseColumnSupport.makeStringValue( pSB , getColumnDefinition() , getLeftValue() );
            pSB.append( " <= " );
            toStringColumnReference( pSB );
            pSB.append( " <= " );
            WhereClauseColumnSupport.makeStringValue( pSB , getColumnDefinition() , getRightValue() );
        }

        protected void toSqlHelper( StringBuffer pSB )
        {
            toSqlColumnReference( pSB );
            pSB.append( isNot() ? " NOT BETWEEN " : " BETWEEN " );
            WhereClauseColumnSupport.makeSqlValue( pSB , getColumnDefinition() , getLeftValue() );
            pSB.append( " AND " );
            WhereClauseColumnSupport.makeSqlValue( pSB , getColumnDefinition() , getRightValue() );
        }
    }

    private static class WC_CONTAINS extends AbstractWhereClauseColumnAndLikeValue
    {
        WC_CONTAINS( SimpleColumnDefinition pColumnDefinition , String pValue )
        {
            super( WhereClause.CONTAINS , pColumnDefinition , true , true , "Contains" , pValue );
        }
    }

    private static class WC_STARTS_WITH extends AbstractWhereClauseColumnAndLikeValue
    {
        WC_STARTS_WITH( SimpleColumnDefinition pColumnDefinition , String pValue )
        {
            super( WhereClause.STARTS_WITH , pColumnDefinition , false , true , "StartsWith" , pValue );
        }
    }

    private static class WC_ENDS_WITH extends AbstractWhereClauseColumnAndLikeValue
    {
        WC_ENDS_WITH( SimpleColumnDefinition pColumnDefinition , String pValue )
        {
            super( WhereClause.ENDS_WITH , pColumnDefinition , true , false , "EndsWith" , pValue );
        }
    }

    private static class WC_IS_IN extends AbstractWhereClauseColumnIsIn
    {
        WC_IS_IN( SimpleColumnDefinition pColumnDefinition , SingleColumnSelect pSingleColumnSelect )
        {
            super( WhereClause.IS_IN , pColumnDefinition , pSingleColumnSelect );
        }
    }
}