/*

 Derby - Class org.apache.derbyTesting.functionTests.tests.store.SpaceTableTest

 Licensed to the Apache Software Foundation (ASF) under one or more
 contributor license agreements.  See the NOTICE file distributed with
 this work for additional information regarding copyright ownership.
 The ASF licenses this file to You under the Apache License, Version 2.0
 (the "License"); you may not use this file except in compliance with
 the License.  You may obtain a copy of the License at

 http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.

 */
package org.apache.derbyTesting.functionTests.tests.store;

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Connection;

import junit.framework.AssertionFailedError;
import junit.framework.Test;

import org.apache.derbyTesting.functionTests.util.Formatters;
import org.apache.derbyTesting.junit.BaseJDBCTestCase;
import org.apache.derbyTesting.junit.CleanDatabaseTestSetup;
import org.apache.derbyTesting.junit.JDBC;
import org.apache.derbyTesting.junit.TestConfiguration;

/**
 * Tests the printing of the WAIT state in the LOCK TABLE.
 */
public class SpaceTableTest extends BaseJDBCTestCase {

    public SpaceTableTest(String name) {
        super(name);
    }

    /**
     * Construct top level suite in this JUnit test
     * The suite is wrapped in a DatabasePropertyTestSetup to set
     * the lock wait timeout.
     *
     * @return A suite containing embedded fixtures
     */
    public static Test suite() {

        Test suite = TestConfiguration.embeddedSuite (SpaceTableTest.class);
        return new CleanDatabaseTestSetup(suite) {
            /**
             * Creates the schemas and table used in the test cases.
             *
             * @throws SQLException
             */
            protected void decorateSQL(Statement s) throws SQLException {
                Connection conn = getConnection();
                conn.setAutoCommit(false);
                String createWaitForPostCommit=
                    "CREATE PROCEDURE WAIT_FOR_POST_COMMIT() " +
                        "DYNAMIC RESULT SETS 0 " +
                        "LANGUAGE JAVA EXTERNAL NAME " +
                        "'org.apache.derbyTesting.functionTests.util.T_Access." +
                            "waitForPostCommitToFinish' " +
                        "PARAMETER STYLE JAVA";
                s.executeUpdate(createWaitForPostCommit);
                conn.commit();
                conn.setAutoCommit(true);
            }
        };
    }

    
    protected void setUp() throws Exception {
        super.setUp();
    }

    /**
     * Tear-down the fixture by removing the tables and schemas
     * @throws Exception
     */
    protected void tearDown() throws Exception {
        Statement stmt = createStatement();
        // cannot drop wait_for_post_commit or it will not exist in
        // all test methods. CleanDatabaseSetup should take care of it.
        // stmt.executeUpdate("drop procedure WAIT_FOR_POST_COMMIT");
        dropTable("IDELETEU");
        dropTable("PLATYPUS");
        dropTable("\"platypus2\"");
        dropFooTables(stmt);
        // force pagesize back to default
        stmt.execute("call SYSCS_UTIL.SYSCS_SET_DATABASE_PROPERTY(" +
                "'derby.storage.pageSize', NULL)");
        commit();
        super.tearDown();
    }

    public void testIDeleteu() throws SQLException, InterruptedException {
        Statement stmt = createStatement();
        stmt.execute("call SYSCS_UTIL.SYSCS_SET_DATABASE_PROPERTY(" +
                "'derby.storage.pageSize', '4096')");
        stmt.executeUpdate("create table ideleteu " +
                "(a varchar(2000), b varchar(2000))");
        String insertString = "insert into ideleteu values ('" +
                Formatters.padString("rrrrrrrrrr",2000) + "', '" +
                Formatters.padString("ssssssssssssssss",2000) + "')";
        for (int i=0; i<5; i++)
        stmt.executeUpdate(insertString);
        
        assertSpaceTableOK("IDELETEU", 
                new String[][]{{"IDELETEU","0","6","0","4096","0"}}, false);
        
        stmt.executeUpdate("delete from ideleteu");
        // explicit commit, superfluous, as autocommit set in decorateSQL
        commit();
        stmt.execute("call WAIT_FOR_POST_COMMIT()");
        // this is one of 2 places where in the sql version of this test we
        // still saw highly intermittent diffs even with the wait for post commit
        // see DERBY-5133. So call to local check.
        assertSpaceTableOK("IDELETEU", 
                new String[][]{{"IDELETEU","0","1","5","4096","20480"}}, true);
        stmt.executeUpdate("drop table ideleteu");
        commit();
        // the default is 4096 (with short columns), so no need to set to storage page size back.
    }
    
    public void testPlatypi() throws SQLException, InterruptedException
    {
        // check results when inserting data after creating indexes
        Statement stmt = createStatement();
        stmt.execute("call SYSCS_UTIL.SYSCS_SET_DATABASE_PROPERTY(" +
                "'derby.storage.pageSize', '4096')");
        JDBC.assertEmpty(doSpaceTableSelect("PLATYPUS"));
        stmt.executeUpdate("create table platypus " +
                "(a varchar(1000), b varchar(3500), " +
                "c varchar(400), d varchar(100))");
        stmt.executeUpdate("create index kookaburra on platypus (a)");
        stmt.executeUpdate("create index echidna on platypus (c)");
        stmt.executeUpdate("create index wallaby on platypus (a,c,d)");
        assertSpaceTableOK("PLATYPUS", new String[][]{
                {"ECHIDNA","1","1","0","4096","0"},
                {"KOOKABURRA","1","1","0","4096","0"},
                {"PLATYPUS","0","1","0","4096","0"},
                {"WALLABY","1","1","0","4096","0"},
                }, false);
        String insertString = "insert into platypus values ('" +
                Formatters.padString("wwwwwww",1000) + "', '" +
                Formatters.padString("xxx",3500) + "', '" +
                Formatters.padString("yy",400) + "', '" +
                Formatters.padString("zzz",100) + "')";
        for (int i=0; i<6; i++)
        stmt.executeUpdate(insertString);
        assertSpaceTableOK("PLATYPUS", new String[][]{
                {"ECHIDNA","1","1","0","4096","0"},
                {"KOOKABURRA","1","4","0","4096","0"},
                {"PLATYPUS","0","13","0","4096","0"},
                {"WALLABY","1","8","0","4096","0"},
                }, false);
        for (int i=0; i<4; i++)
        stmt.executeUpdate(insertString);
        assertSpaceTableOK("PLATYPUS", new String[][]{
                {"ECHIDNA","1","3","0","4096","0"},
                {"KOOKABURRA","1","8","0","4096","0"},
                {"PLATYPUS","0","21","0","4096","0"},
                {"WALLABY","1","16","0","4096","0"},
                }, false);
        stmt.executeUpdate("delete from platypus");
        // we've got autocommit on, so there was a commit...
        stmt.execute("call WAIT_FOR_POST_COMMIT()");
        assertSpaceTableOK("PLATYPUS", new String[][]{
                {"ECHIDNA","1","1","2","4096","8192"},
                {"KOOKABURRA","1","1","7","4096","28672"},
                {"PLATYPUS","0","1","20","4096","81920"},
                {"WALLABY","1","15","1","4096","4096"},
                }, true);
        
        // check the results when we create indexes after inserting data
        // also note this table has lower case name
        stmt.executeUpdate("create table \"platypus2\" " +
                "(a varchar(10), b varchar(1500), " +
                "c varchar(400), d varchar(100))");
        insertString = "insert into \"platypus2\" values ('" +
                Formatters.padString("wwwwwww",10) + "', '" +
                Formatters.padString("xxx",1500) + "', '" +
                Formatters.padString("yy",400) + "', '" +
                Formatters.padString("zzz",100) + "')";
        for (int i=0; i<6; i++)
        stmt.executeUpdate(insertString);
        stmt.executeUpdate("create index kookaburra2 on \"platypus2\" (a)");
        stmt.executeUpdate("create index echidna2 on \"platypus2\" (c)");
        stmt.executeUpdate("create index wallaby2 on \"platypus2\" (a,c,d)");
        assertSpaceTableOK("platypus2", new String[][]{
                {"ECHIDNA2","1","1","0","4096","0"},
                {"KOOKABURRA2","1","1","0","4096","0"},
                {"WALLABY2","1","1","0","4096","0"},
                {"platypus2","0","6","0","4096","0"},
                }, false);

        ResultSet rs = stmt.executeQuery(
                "select conglomeratename, isindex, numallocatedpages, " +
                "numfreepages, pagesize, estimspacesaving " +
                "from SYS.SYSSCHEMAS s, " +
                "SYS.SYSTABLES t, " +
                "new org.apache.derby.diag.SpaceTable(SCHEMANAME,TABLENAME) v " +
                "where s.SCHEMAID = t.SCHEMAID " +
                "and s.SCHEMANAME = 'APP' " +
                "order by conglomeratename");
        JDBC.assertFullResultSet(rs, new String [][] {
                {"ECHIDNA","1","1","2","4096","8192"},
                {"ECHIDNA2","1","1","0","4096","0"},
                {"KOOKABURRA","1","1","7","4096","28672"},
                {"KOOKABURRA2","1","1","0","4096","0"},
                {"PLATYPUS","0","1","20","4096","81920"},
                {"WALLABY","1","15","1","4096","4096"},
                {"WALLABY2","1","1","0","4096","0"},
                {"platypus2","0","6","0","4096","0"},
                });
        stmt.executeUpdate("drop table platypus");
        stmt.executeUpdate("drop table \"platypus2\"");
    }
    
    public void testReservedSpace() throws SQLException, InterruptedException
    {
        Statement stmt = createStatement();
        // first ensure we're using the default.
        stmt.execute("call SYSCS_UTIL.SYSCS_SET_DATABASE_PROPERTY(" +
                "'derby.storage.pageSize', '4096')");
        setAutoCommit(false);
        
        // no reserved space set - default
        stmt.executeUpdate("create table foo_int (a int)");
        stmt.executeUpdate("create table foo_char (a char(100))");
        stmt.executeUpdate("create table foo_varchar (a varchar(32000))");
        // let the foo_longxxx get created at 32K (the default for long types)
        stmt.execute("call SYSCS_UTIL.SYSCS_SET_DATABASE_PROPERTY(" +
                "'derby.storage.pageSize', NULL)");
        stmt.executeUpdate("create table foo_longvarchar (a long varchar)");
        stmt.executeUpdate("create table foo_longvarbinary " +
                "(a long varchar for bit data)");
        // Back to 4K
        stmt.execute("call SYSCS_UTIL.SYSCS_SET_DATABASE_PROPERTY(" +
                "'derby.storage.pageSize', '4096')");
        stmt.executeUpdate("create table foo_bit (a char(100) for bit data)");
        stmt.executeUpdate("create table foo_varbinary " +
                "(a varchar(1000) for bit data)");
        
        JDBC.assertFullResultSet(doSpaceTableSelect2(), new String [][] {
                {"FOO_BIT","4096"},
                {"FOO_CHAR","4096"},
                {"FOO_INT","4096"},
                {"FOO_LONGVARBINARY","32768"},
                {"FOO_LONGVARCHAR","32768"},
                {"FOO_VARBINARY","4096"},
                {"FOO_VARCHAR","4096"},
                });
        
        dropFooTables(stmt);
        
        // test with 65K reserved space
        stmt.execute("call SYSCS_UTIL.SYSCS_SET_DATABASE_PROPERTY(" +
                "'derby.storage.ReservedSpace', '65')");
        stmt.executeUpdate("create table foo_int (a int)");
        stmt.executeUpdate("create table foo_char (a char(100))");
        stmt.executeUpdate("create table foo_varchar (a varchar(32000))");
        // let the foo_longxxx get created at 32K (the default for long types)
        stmt.execute("call SYSCS_UTIL.SYSCS_SET_DATABASE_PROPERTY(" +
                "'derby.storage.pageSize', NULL)");
        stmt.executeUpdate("create table foo_longvarchar (a long varchar)");
        stmt.executeUpdate("create table foo_longvarbinary " +
                "(a long varchar for bit data)");
        // Back to 4K
        stmt.execute("call SYSCS_UTIL.SYSCS_SET_DATABASE_PROPERTY(" +
                "'derby.storage.pageSize', '4096')");
        stmt.executeUpdate("create table foo_bit (a char(100) for bit data)");
        stmt.executeUpdate("create table foo_varbinary " +
                "(a varchar(1000) for bit data)");
        
        // reset the reserved space to default (by setting property to NULL)
        stmt.execute("call SYSCS_UTIL.SYSCS_SET_DATABASE_PROPERTY(" +
                "'derby.storage.ReservedSpace', NULL)");
        
        JDBC.assertFullResultSet(doSpaceTableSelect2(), new String [][] {
            {"FOO_BIT","4096"},
            {"FOO_CHAR","4096"},
            {"FOO_INT","4096"},
            {"FOO_LONGVARBINARY","32768"},
            {"FOO_LONGVARCHAR","32768"},
            {"FOO_VARBINARY","4096"},
            {"FOO_VARCHAR","4096"},
            });
        
        dropFooTables(stmt);
        
        // 8K pagesize
        stmt.execute("call SYSCS_UTIL.SYSCS_SET_DATABASE_PROPERTY(" +
                "'derby.storage.pageSize', '8192')");
        stmt.executeUpdate("create table foo_int (a int)");
        stmt.executeUpdate("create table foo_char (a char(100))");
        stmt.executeUpdate("create table foo_varchar (a varchar(32000))");
        stmt.executeUpdate("create table foo_longvarchar (a long varchar)");
        stmt.executeUpdate("create table foo_longvarbinary " +
                "(a long varchar for bit data)");
        stmt.executeUpdate("create table foo_bit (a char(100) for bit data)");
        stmt.executeUpdate("create table foo_varbinary " +
                "(a varchar(1000) for bit data)");
        
        JDBC.assertFullResultSet(doSpaceTableSelect2(), new String [][] {
            {"FOO_BIT","8192"},
            {"FOO_CHAR","8192"},
            {"FOO_INT","8192"},
            {"FOO_LONGVARBINARY","8192"},
            {"FOO_LONGVARCHAR","8192"},
            {"FOO_VARBINARY","8192"},
            {"FOO_VARCHAR","8192"},
            });
        
        dropFooTables(stmt);
        
        // test with commit after setting pageSize at 4096
        stmt.execute("call SYSCS_UTIL.SYSCS_SET_DATABASE_PROPERTY(" +
                "'derby.storage.pageSize', '4096')");
        commit();
        stmt.executeUpdate("create table foo_int (a int)");
        stmt.executeUpdate("create table foo_char (a char(100))");
        stmt.executeUpdate("create table foo_varchar (a varchar(32000))");
        stmt.executeUpdate("create table foo_longvarchar (a long varchar)");
        stmt.executeUpdate("create table foo_longvarbinary " +
                "(a long varchar for bit data)");
        stmt.executeUpdate("create table foo_bit (a char(100) for bit data)");
        stmt.executeUpdate("create table foo_varbinary " +
                "(a varchar(1000) for bit data)");
        
        JDBC.assertFullResultSet(doSpaceTableSelect2(), new String [][] {
            {"FOO_BIT","4096"},
            {"FOO_CHAR","4096"},
            {"FOO_INT","4096"},
            {"FOO_LONGVARBINARY","4096"},
            {"FOO_LONGVARCHAR","4096"},
            {"FOO_VARBINARY","4096"},
            {"FOO_VARCHAR","4096"},
            });
        
        commit();
        dropFooTables(stmt);
        commit();
    }
    
    private ResultSet doSpaceTableSelect(String tableName) throws SQLException
    {
        ResultSet rs = null;
        String stmt_str = 
                "select " + 
                        "conglomeratename, " +
                        "isindex, "           + 
                        "numallocatedpages, " + 
                        "numfreepages, "      + 
                        "pagesize, "          + 
                        "estimspacesaving "   + 
                        "from new org.apache.derby.diag.SpaceTable('" +
                        tableName + "') t order by conglomeratename";

        PreparedStatement space_stmt = prepareStatement(stmt_str);
        rs = space_stmt.executeQuery();
        return rs;
    }
    
    private ResultSet doSpaceTableSelect2() throws SQLException
    {
        ResultSet rs = null;
        String stmt_str = 
                "select " + 
                        "v.conglomeratename, pagesize " +
                        "from SYS.SYSSCHEMAS s, SYS.SYSTABLES t, " +
                        "new org.apache.derby.diag.SpaceTable(" +
                        "schemaname, tablename) v " +
                        "where s.schemaid=t.schemaid and " +
                        "conglomeratename in (" +
                        "'FOO_INT', 'FOO_VARCHAR', 'FOO_CHAR', 'FOO_LONGVARCHAR'," +
                        "'FOO_VARBINARY', 'FOO_LONGVARBINARY', 'FOO_BIT') " +
                        "order by 1";

        PreparedStatement space_stmt = prepareStatement(stmt_str);
        rs = space_stmt.executeQuery();
        return rs;
    }
    
    private void assertSpaceTableOK(String tableName, String[][] expRS, 
            boolean trytwice)
            throws SQLException, InterruptedException {
        ResultSet rs = doSpaceTableSelect(tableName);
        try {
            JDBC.assertFullResultSet(rs, expRS );
        } catch (AssertionFailedError e) {
            if (trytwice) {
                assertSpaceTableOK(tableName, expRS, false);
            } else {
                throw e;
            }
        }
    }
    
    public void dropFooTables(Statement stmt) throws SQLException {
        dropTable("FOO_INT");
        dropTable("FOO_CHAR");
        dropTable("FOO_VARCHAR");
        dropTable("FOO_LONGVARCHAR");
        dropTable("FOO_LONGVARBINARY");
        dropTable("FOO_BIT");
        dropTable("FOO_VARBINARY");
    }
}