Como um servidor SQL interpreta a string com a query e finalmente executa o que ela solicitou

Programação Arquitetura
#1

Salve pessoal,

tenho uma dúvida com relação ao funcionamento de uma instrução SQL; O cliente se conecta ao servidor via TCP, toda comunicação entre o cliente e o servidor é feita pelo envio de strings, certo? Quando a gente faz uma query Ex: SELECT * from tabela, essa string da query vai ser enviada pelo TCP ao servidor que vai tratar ela, daí ele abre os arquivos locais(tabela) e procura o que foi requisitado e manda os dados na resposta(suponho que seja por stream). Se até eu não falei besteira, . Como a rotina que interpreta as instruções SQL e traduz pro resto do script pra que ele busque no arquivo exatamente o que foi requisitado na query?

Ex: se todas as instruções fossem SELECT * FROM tabela WHERE … ou UPDATE tabela SET sss=‘sss’ WHERE… etc, eu faria uma rotina que iria tratar a string com a instrução e enfim fazer a query. Como a gente já sabe existem trocentas formas de fazer instrução “SELECT * FROM…”, “SELECT campo1, campo2, campo3 FROM…”, SELECT a.campo1, b.campo1…

A minha intenção é montar um servidor de banco de dados e pra isso eu tô tentando entender como funciona lá nos bastidores e tentar seguir op padrão.

Valeu e desde já agradeço à galera aí que puder dar um help, []'s.

#2

Uma forma é pegar o fonte do HSQLDB ( http://hsqldb.soruceforge.net ) e tentar entender mais ou menos o que ocorre. Ele não tem otimização no SQL nem usa algoritmos muito complexos no acesso aos dados (ou seja, para qualquer consulta de dados grande ou complexa ele abre o bico), mas para entender o que se passa é bem legal.

#3

Aham, é “http://hsqldb.sourceforge.net”. Desculpem nossa falha…

#4

Cara valeu mesmo pela dica, vi a rotina, ele faz exatamente o que eu tava pensando, pega a string da variável “cmd” que é a que vem pelo tcp, trata ela e dá esse switch aí,

switch (cmd) {

                case SELECT :
                    rResult = p.processSelect();
                    break;

                case INSERT :
                    rResult = p.processInsert();
        send_update=true;
                    break;

                case UPDATE :
                    rResult = p.processUpdate();
        send_update=true;
                    break;

                case DELETE :
                    rResult = p.processDelete();
        send_update=true;
                    break;

                case CALL :
                    rResult = p.processCall();
        send_update=true;
                    break;

                case SET :
                    rResult = processSet(c, session);
        send_update=true;
                    break;

                case COMMIT :
                    rResult = processCommit(c, session);

                    session.setScripting(true);
        send_update=true;
                    break;

                case ROLLBACK :
                    rResult = processRollback(c, session);

                    session.setScripting(true);
        send_update=true;
                    break;

                case SAVEPOINT :
                    rResult = processSavepoint(c, session);

                    session.setScripting(true);
        send_update=true;
                    break;

                case CREATE :
                    rResult = processCreate(c, session);
        send_update=true;
                    break;

                case ALTER :
                    rResult = processAlter(c, session);
        send_update=true;
                    break;

                case DROP :
                    rResult = processDrop(c, session);
        send_update=true;
                    break;

                case GRANT :
                    rResult = processGrantOrRevoke(c, session, true);
        send_update=true;
                    break;

                case REVOKE :
                    rResult = processGrantOrRevoke(c, session, false);
        send_update=true;
                    break;

                case CONNECT :
                    rResult = processConnect(c, session);
                    break;

                case DISCONNECT :
                    rResult = processDisconnect(session);
                    break;

                case SCRIPT :
                    rResult = processScript(c, session);
                    break;

                case SHUTDOWN :
                    rResult = processShutdown(c, session);
                    break;

                case CHECKPOINT :
                    rResult = processCheckpoint(session);
        send_update=true;
                    break;

                case SEMICOLON :
                    break;
            }

pra cada tipo de instrução ele criou uma função pra fazer o tratamento, maneiro valeu mesmo… []'s.

#5