Quadcap Embeddable Database

com/quadcap/sql/StmtRenameTable.java

Go to the documentation of this file.

package com.quadcap.sql;

/* Copyright 1999 - 2003 Quadcap Software.  All rights reserved.
 *
 * This software is distributed under the Quadcap Free Software License.
 * This software may be used or modified for any purpose, personal or
 * commercial.  Open Source redistributions are permitted.  Commercial
 * redistribution of larger works derived from, or works which bundle
 * this software requires a "Commercial Redistribution License"; see
 * http://www.quadcap.com/purchase.
 *
 * Redistributions qualify as "Open Source" under  one of the following terms:
 *   
 *    Redistributions are made at no charge beyond the reasonable cost of
 *    materials and delivery.
 *
 *    Redistributions are accompanied by a copy of the Source Code or by an
 *    irrevocable offer to provide a copy of the Source Code for up to three
 *    years at the cost of materials and delivery.  Such redistributions
 *    must allow further use, modification, and redistribution of the Source
 *    Code under substantially the same terms as this license.
 *
 * Redistributions of source code must retain the copyright notices as they
 * appear in each source code file, these license terms, and the
 * disclaimer/limitation of liability set forth as paragraph 6 below.
 *
 * Redistributions in binary form must reproduce this Copyright Notice,
 * these license terms, and the disclaimer/limitation of liability set
 * forth as paragraph 6 below, in the documentation and/or other materials
 * provided with the distribution.
 *
 * The Software is provided on an "AS IS" basis.  No warranty is
 * provided that the Software is free of defects, or fit for a
 * particular purpose.  
 *
 * Limitation of Liability. Quadcap Software shall not be liable
 * for any damages suffered by the Licensee or any third party resulting
 * from use of the Software.
 */

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import java.sql.SQLException;

import com.quadcap.sql.file.BlockFile;
import com.quadcap.sql.file.ByteUtil;

import com.quadcap.sql.index.Btree;
import com.quadcap.sql.index.BCursor;

import com.quadcap.sql.io.Extern;

import com.quadcap.util.Debug;

/**
 * Implementation of the SQL <b>ALTER TABLE RENAME TO</b> statement. 
 *
 * @author Stan Bailes
 */

public class StmtRenameTable extends LogStep implements Stmt, Externalizable {
    String                      oldName;
    String                      newName;
    Relation                    r;

    public StmtRenameTable() {}
    
    public StmtRenameTable(String oldName, String newName) {
        this.oldName = oldName;
        this.newName = newName;
    }

    public void execute(Session session) throws IOException, SQLException {
        session.getTableWriteLock("#Schema");
        session.getTableWriteLock(oldName);
        session.getTableWriteLock(newName);
        session.doStep(this);
    }

    public void redo(Session session) throws IOException, SQLException {
        rename(session, oldName, newName);
    }

    public void undo(Session session) throws IOException, SQLException {
        rename(session, newName, oldName);
    }

    public void rename(Session session, String oldN, String newN)
        throws IOException, SQLException
    {
        Database db = session.getDatabase();
        Relation oldR = db.getRelation(oldN);
        if (oldR == null) {
            throw new SQLException("no such table: " + oldN, "42000");
        }
        db.renameRelation(oldR, newN);
        Relation newR = db.getRelation(newN);
        if (newR == null) {
            throw new SQLException("rename failed!: " + newN);
        }
            
        Enumeration views = db.getViews(newN);
        while (views.hasMoreElements()) {
            String view1 = views.nextElement().toString();
            renameView(session, view1, oldN, newN);
        }

        if (newR instanceof Table) {
            Map referencingTables = new HashMap();
            Table t = (Table)newR;
            int num = t.getNumConstraints();
            for (int i = 0; i < num; i++) {
                Constraint c = t.getConstraint(i);
                if (c instanceof ForeignKeyConstraint) {
                    ForeignKeyConstraint fc = (ForeignKeyConstraint)c;
                    String fTable = fc.getFTableName();
                    referencingTables.put(fTable, "");
                }
            }
            if (referencingTables.size() > 0) {
                Iterator iter = referencingTables.keySet().iterator();
                while (iter.hasNext()) {
                    renameForeignKeys(session, iter.next().toString(), oldN, newN);
                }
                db.updateRelation(newR);
            }
        }
    }
    
    void renameForeignKeys(Session session, String tableName, String oldN,
                           String newN)
        throws IOException, SQLException
    {
        session.getTableReadLock(tableName);
        Database db = session.getDatabase();
        Table t = (Table)db.getRelation(tableName);
        int num = t.getNumConstraints();
        for (int i = 0; i < num; i++) {
            Constraint c = t.getConstraint(i);
            if (c instanceof ForeignKeyConstraint) {
                ForeignKeyConstraint fc = (ForeignKeyConstraint)c;
                String fTable = fc.getFTableName();
                if (fTable.equals(oldN)) {
                    fc.setFTableName(newN);
                    fc.resetColumns();
                }
            }
        }
        db.updateRelation(t);
    }

    class RenameTableVisitor implements ExpressionVisitor {
        String                  oldN;
        String                  newN;
        RenameTableVisitor(String oldN, String newN) {
            this.oldN = oldN;
            this.newN = newN;
        }                
        public void visit(Expression ex) {
            if (ex instanceof SelectFromTable) {
                SelectFromTable sf = (SelectFromTable)ex;
                String tableName = sf.getTableName();
                if (tableName.equals(oldN)) {
                    sf.setTableName(newN);
                }
            } else if (ex instanceof SelectExpression) {
                Iterator iter = ((SelectExpression)ex).getFrom().iterator();
                while (iter.hasNext()) {
                    visit((Expression)iter.next());
                }
            }
            ex.visitSubExpressions(this);
        }
    }
    
    void renameView(Session session, String viewName, String oldN,
                    String newN)
        throws IOException, SQLException
    {

        session.getTableReadLock(viewName);

        Database db = session.getDatabase();
        View v = (View)db.getRelation(viewName);
        Expression viewEx = v.getViewExpression();
        RenameTableVisitor visitor = new RenameTableVisitor(oldN, newN);
        visitor.visit(viewEx);
        db.updateRelation(v);
    }

    public void prepare(Session session) throws IOException, SQLException {
    }

    public void readExternal(ObjectInput in)
        throws IOException, ClassNotFoundException
    {
        oldName = (String)in.readObject();
        newName = (String)in.readObject();
    }
    
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(oldName);
        out.writeObject(newName);
    }

    //#ifdef DEBUG
    /**
     * Return a displayable representation for debugging
     */
    public String toString() {
        StringBuffer sb = new StringBuffer(super.toString());
        sb.append(" RenameTable(");
        sb.append(oldName);
        sb.append(" to ");
        sb.append(newName);
        sb.append(')');
        return sb.toString();
    }
    //#endif

    static Extern extern;
    public void setExtern(Extern extern) { StmtRenameTable.extern = extern; }
    public Extern getExtern() { return extern; }
}