9090

main.py

@@ -1,38 +1,129 @@
 import os
+import getpass
+import mysql.connector
 
 from table import Table
 from sql import SQL
+from mysql.connector import Error
 
 def main():
-    print("Bem vindo ao SGBD")
-    print("Digite a pasta onde está os arquivos CSV:")
-    #csv_folder = input()
-    csv_folder = "./source"
+    print("Bem-vindo!")
+    print("Inicialmente, os dados precisam ser importados do MySQL")
+    print("Caso isso já tenha sido feito, os arquivos .csv serao sobreescritos")
+    print("Se algum update,insert ou delete tenha sido feito, ele sera perdido")
+    print("Eh recomendado importar as tabelas do bando de dados pelo menos no primeiro acesso")
+    print("Deseja importar os dados (digite BD) ou utilizar os arquivos.csv (digite CSV)?")
+    escolha = input()
 
     tables = {}
 
-    # get all csv files in the folder
-    for file in os.listdir(csv_folder):
-        if file.endswith(".csv"):
-            table_name = file.split(".")[0]
-            table = Table(table_name)
-            table.load_from_csv(f"{csv_folder}/{file}")
-            tables[table_name] = table
+    if escolha == "CSV":
+        print("Espere os arquivos.csv carregarem...")
+        #print("Digite a pasta onde estão os arquivos CSV:")
+        #csv_folder = input()
+        csv_folder = "./source"
 
-    print("Tabelas carregadas:")
-    print(tables.keys())
+        # Seleciona todos o csv presentes na pasta
+        for file in os.listdir(csv_folder):
+            if file.endswith(".csv"):
+                table_name = file.split(".")[0]
+                table = Table(table_name)
+                table.load_from_csv(f"{csv_folder}/{file}")
+                tables[table_name] = table
 
-    while True:
-        print("Digite a query [0 para sair]:")
-        query = input()
+        print("\nTabelas carregadas:")
+        print(', '.join(tables.keys())+"\n")
 
-        if query == "0":
-            break
+        while True:
+            print("Digite a query [0 para sair]:")
+            query = input()
 
-        sql = SQL(tables, query)
-        sql.execute()
+            if query == "0":
+                break
 
-        print()
+            sql = SQL(tables, query)
+            sql.execute()
+
+            print()
+
+    elif escolha == "BD":
+
+        print("Host (localhost):")
+        host_name = input()
+
+        print("Database (employees):")
+        database_name = input()
+
+        print("User:")
+        user_name = input()
+
+        password_name = getpass.getpass()
+
+        try:
+
+            connection = mysql.connector.connect(host=host_name,
+                                         database=database_name,
+                                         user=user_name,
+                                         password=password_name)
+            
+            if connection.is_connected():
+                print("Conectado ao employees-db")
+                cursor = connection.cursor()
+
+            cursor.execute("SHOW TABLES")
+            tables_names = cursor.fetchall()
+
+            for table_name in tables_names:
+                # table_name = ('departments', )
+                table_name = table_name[0]
+                # table_name = 'departments'
+
+                print('Carregando', table_name)
+                tables[table_name] = Table(table_name)
+                tables[table_name].load_from_mysql(table_name,cursor)
+                tables[table_name].save_to_csv()
+                print('Carregado', table_name)
+
+        except Error as e:
+            print("Error while connecting to MySQL", e)
+        finally:
+            if connection.is_connected():
+                cursor.close()
+                connection.close()
+                print("MySQL connection is closed")
+
+        print("Espere os arquivos.csv carregarem...")
+        #print("Digite a pasta onde estão os arquivos CSV:")
+        #csv_folder = input()
+        csv_folder = "./source"
+
+        tables = {}
+
+        # Seleciona todos o csv presentes na pasta
+        for file in os.listdir(csv_folder):
+            if file.endswith(".csv"):
+                table_name = file.split(".")[0]
+                table = Table(table_name)
+                table.load_from_csv(f"{csv_folder}/{file}")
+                tables[table_name] = table
+
+        print("\nTabelas carregadas:")
+        print(', '.join(tables.keys())+"\n")
+
+        while True:
+            print("Digite a query [0 para sair]:")
+            query = input()
+
+            if query == "0":
+                break
+
+            sql = SQL(tables, query)
+            sql.execute()
+
+            print()
+
+    else:
+        print("Fora do intervalo!")
 
 if __name__ == "__main__":
     main()

source/city.csv

@@ -1,4 +1,4 @@
-city,state,country
-London,England,United Kingdom
-Kansas City,Kansas,United States
-Rio de Janeiro,Rio de Janeiro,Brazil
+city,state,country
+London,England,United Kingdom
+Kansas City,Kansas,United States
+city,parana,goiania

sql.py

@@ -1,38 +1,47 @@
-from table import Table
-
 class SQL:
     def __init__(self, tables: dict, query: str) -> None:
         self.tables = tables
         self.query = query.replace(";", "")
 
-    def __str__(self) -> str:
-        pass
+    def _try_parse_int(self, value: str) -> int:
+        try:
+            return int(value)
+        except ValueError:
+            return value
 
-    # SELECIONAR * DE tabela
+    # ISCOLHE * DE tabela
     def execute(self):
         query_parts = self.query.split(" ")
 
-        if query_parts[0] == "SELECIONAR":
+        if query_parts[0] == "ISCOLHE":
             self.select(query_parts)
+        elif query_parts[0] == "BOTAR":
+            self.insert(query_parts)
+        elif query_parts[0] == "SUMIR":
+            self.delete(query_parts)
+        elif query_parts[0] == "UPDEITA":
+            self.update(query_parts)
         else:
             pass
 
-    # SELECIONAR * DE tabela JUNTAR tabela2 coluna ONDE coluna = valor
+    # ISCOLHE * DE tabela AJUNTAR tabela2 EM coluna;
+    # ISCOLHE * DE tabela DONDE coluna = valor;
     def select(self, query_parts: list) -> None:
         where_filter = None
         join_stmt = None
 
-        if "JUNTAR" in query_parts:
-            index = query_parts.index("JUNTAR")
+        if "AJUNTAR" in query_parts:
+            index = query_parts.index("AJUNTAR")
             join_table = query_parts[index + 1]
-            join_column = query_parts[index + 2]
+            join_operator = query_parts[index + 2] # EM -> estetico
+            join_column = query_parts[index + 3]
             join_stmt = [self.tables[join_table], join_column]
 
-        if "ONDE" in query_parts:
-            index = query_parts.index("ONDE")
+        if "DONDE" in query_parts:
+            index = query_parts.index("DONDE")
             where_filter_column = query_parts[index + 1]
             where_filter_operator = query_parts[index + 2]
-            where_filter_value = query_parts[index + 3]
+            where_filter_value = self._try_parse_int(query_parts[index + 3])
             where_filter = [where_filter_column, where_filter_operator, where_filter_value]
 
         # parse TABLE
@@ -87,6 +96,155 @@ class SQL:
             row_values = []
             for column in column_list:
                 column_index = tables_columns.index(column)
-                row_values.append(row[column_index])
+                row_values.append(str(row[column_index]))
 
             print(', '.join(row_values))
+
+    # BOTAR tabela Coluna1,Coluna2,Coluna3 VALORES Valor1,Valor2,Valor3
+    def insert(self, query_parts: list) -> None:
+        insert_tabela = None
+        insert_colunas = []
+        insert_valores = []
+
+        index = query_parts.index("BOTAR")
+        insert_tabela = query_parts[index + 1]
+        insert_colunas = query_parts[index + 2].split(",")
+        insert_valores = query_parts[index + 4].split(",")
+
+        table = self.tables[insert_tabela]
+
+        row_value = []
+        for column_index in range(len(table.columns)):
+            column_name = table.columns[column_index]
+
+            try:
+                coluna_index = insert_colunas.index(column_name)
+                valor = self._try_parse_int(insert_valores[coluna_index])
+            except ValueError:
+                coluna_index = -1
+                valor = ""
+
+            row_value.append(valor)
+
+        table.rows.append(row_value)
+        table.save_to_csv()
+
+    # BOTAR tabela Coluna1,Coluna2,Coluna3 VALORES Valor1,Valor2,Valor3
+    def insert(self, query_parts: list) -> None:
+        insert_tabela = None
+        insert_colunas = []
+        insert_valores = []
+
+        index = query_parts.index("BOTAR")
+        insert_tabela = query_parts[index + 1]
+        insert_colunas = query_parts[index + 2].split(",")
+        insert_valores = query_parts[index + 4].split(",")
+
+        table = self.tables[insert_tabela]
+
+        row_value = []
+        for column_index in range(len(table.columns)):
+            column_name = table.columns[column_index]
+
+            try:
+                coluna_index = insert_colunas.index(column_name)
+                valor = self._try_parse_int(insert_valores[coluna_index])
+            except ValueError:
+                coluna_index = -1
+                valor = ""
+
+            row_value.append(valor)
+
+        table.rows.append(row_value)
+        table.save_to_csv()
+
+    # SUMIR tabela DONDE coluna = valor
+    def delete(self, query_parts: list) -> None:
+        delete_tabela = None
+        delete_coluna = None
+        delete_condicao = None
+        delete_valor = None
+
+        index = query_parts.index("SUMIR")
+        delete_tabela = query_parts[index + 1]
+        delete_coluna = query_parts[index + 3]
+        delete_condicao = query_parts[index + 4]
+        delete_valor = self._try_parse_int(query_parts[index + 5])
+
+        table = self.tables[delete_tabela]
+
+        for row in table.rows:
+            column_index = table.columns.index(delete_coluna)
+
+            if delete_condicao == '=' and row[column_index] == delete_valor:
+                table.rows.remove(row)
+            elif delete_condicao == '<' and row[column_index] < delete_valor:
+                table.rows.remove(row)
+            elif delete_condicao == '>' and row[column_index] > delete_valor:
+                table.rows.remove(row)
+            elif delete_condicao == '!=' and row[column_index] != delete_valor:
+                table.rows.remove(row)
+
+        table.save_to_csv()
+
+    # SUMIR tabela DONDE coluna = valor
+    def delete(self, query_parts: list) -> None:
+        delete_tabela = None
+        delete_coluna = None
+        delete_condicao = None
+        delete_valor = None
+
+        index = query_parts.index("SUMIR")
+        delete_tabela = query_parts[index + 1]
+        delete_coluna = query_parts[index + 3]
+        delete_condicao = query_parts[index + 4]
+        delete_valor = self._try_parse_int(query_parts[index + 5])
+
+        table = self.tables[delete_tabela]
+
+        column_index = table.columns.index(delete_coluna)
+
+        for row in table.rows:
+            if delete_condicao == '=' and row[column_index] == delete_valor:
+                table.rows.remove(row)
+            elif delete_condicao == '<' and row[column_index] < delete_valor:
+                table.rows.remove(row)
+            elif delete_condicao == '>' and row[column_index] > delete_valor:
+                table.rows.remove(row)
+            elif delete_condicao == '!=' and row[column_index] != delete_valor:
+                table.rows.remove(row)
+
+        table.save_to_csv()
+
+    # UPDEITA tabela coluna PARA valor DONDE coluna = valor
+    def update(self, query_parts: list) -> None:
+        update_tabela = None
+        update_coluna = None
+        update_valor = None
+
+        index = query_parts.index("UPDEITA")
+        update_tabela = query_parts[index + 1]
+        update_coluna = query_parts[index + 2]
+        update_valor = self._try_parse_int(query_parts[index + 4])
+        
+        index = query_parts.index("DONDE")
+        update_where_coluna = query_parts[index + 1]
+        update_where_condicao = query_parts[index + 2]
+        update_where_valor = query_parts[index + 3]
+
+        table = self.tables[update_tabela]
+
+        update_col_index = table.columns.index(update_coluna)
+        where_col_index = table.columns.index(update_where_coluna)
+
+        for i in range(len(table.rows)):
+            if update_where_condicao == '=' and table.rows[i][where_col_index] == update_where_valor:
+                table.rows[i][update_col_index] = update_valor
+            elif update_where_condicao == '<' and table.rows[i][where_col_index] < update_where_valor:
+                table.rows[i][update_col_index] = update_valor
+            elif update_where_condicao == '>' and table.rows[i][where_col_index] > update_where_valor:
+                table.rows[i][update_col_index] = update_valor
+            elif update_where_condicao == '!=' and table.rows[i][where_col_index] != update_where_valor:
+                table.rows[i][update_col_index] = update_valor
+
+        table.save_to_csv()

table.py

@@ -10,43 +10,72 @@ class Table:
     def __repr__(self):
         return self.name
 
+    def _try_parse_int(self, value: str) -> int:
+        try:
+            return int(value)
+        except ValueError:
+            return value
+
     def load_from_csv(self, csv_file):
         with open(csv_file, 'r') as f:
             reader = f.read().splitlines()
 
-            # First line is the column names
+            # Primeira linha contêm o nome das colunas
             self.columns = reader[0].split(',')
             reader.pop(0)
 
             for row in reader:
                 row = row.split(',')
-                self.rows.append(row)
+                row_list = []
 
-    def print_columns(self, column_list: list, where_filter: list = None, join_stmt: list = None):
-        if column_list[0] == '*':
-            column_list = self.columns
+                for column in row:
+                    row_list.append(self._try_parse_int(column))
 
-        print(', '.join(column_list))
-        print('-' * 20)
+                self.rows.append(row_list)
 
-        for row in self.rows:
-            if where_filter is not None:
-                column_index = self.columns.index(where_filter[0])
-                row_value = row[column_index]
+    def load_from_mysql(self, table_name, cursor):
+        cursor.execute("SELECT * FROM " + table_name)
+        rows = cursor.fetchall()
 
-                if where_filter[1] == '=':
-                    if row_value != where_filter[2]:
-                        continue
-                elif where_filter[1] == '>':
-                    if row_value <= where_filter[2]:
-                        continue
-                elif where_filter[1] == '<':
-                    if row_value >= where_filter[2]:
-                        continue
+        for row in rows:
+            row_list = []
 
-            row_values = []
-            for column in column_list:
-                column_index = self.columns.index(column)
-                row_values.append(row[column_index])
+            for col in row:
+                row_list.append(col)
 
-            print(', '.join(row_values))
+            self.rows.append(row_list)
+
+            '''
+            self.rows = [
+                ["dp001", "Customer Service"]
+            ]
+            '''
+
+        cursor.execute("SHOW COLUMNS FROM " + table_name)
+        columns = cursor.fetchall()
+        
+        for row in columns:
+            self.columns.append(row[0])
+
+    def save_to_csv(self):
+        f = open("./source/" + self.name + ".csv", "w")
+
+        # gravar o cabeçalho
+        columns_line = ""
+        for i in range(len(self.columns)):
+            columns_line = columns_line + self.columns[i]
+            if i < len(self.columns) - 1:
+                columns_line = columns_line + ","
+        f.write(columns_line + '\n')
+
+        for line in range(len(self.rows)):
+            data_line = ""
+
+            for column in range(len(self.columns)):
+                data_line = data_line + str(self.rows[line][column])
+                if column < len(self.columns) - 1:
+                    data_line = data_line + ","
+
+            f.write(data_line + '\n')
+
+        f.close()