sqlshell 0.4.4__py3-none-any.whl

sqlshell/splash_screen.py

@@ -0,0 +1,405 @@
+from PyQt6.QtWidgets import QWidget, QLabel, QVBoxLayout
+from PyQt6.QtCore import Qt, QTimer, QPropertyAnimation, QEasingCurve, QPoint, QRect, pyqtProperty
+from PyQt6.QtGui import QPainter, QColor, QFont, QMovie, QPainterPath, QLinearGradient, QPixmap
+import os
+
+class AnimatedSplashScreen(QWidget):
+    def __init__(self):
+        super().__init__()
+        
+        # Initialize properties for animations first
+        self._opacity = 0.0
+        self._progress = 0.0
+        self.next_widget = None
+        self.use_fallback = False
+        
+        # Set up the window properties
+        self.setWindowFlags(
+            Qt.WindowType.WindowStaysOnTopHint |
+            Qt.WindowType.FramelessWindowHint |
+            Qt.WindowType.SplashScreen
+        )
+        
+        # Set widget attributes for proper compositing
+        self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
+        self.setAttribute(Qt.WidgetAttribute.WA_NoSystemBackground)
+        self.setAttribute(Qt.WidgetAttribute.WA_TransparentForMouseEvents, False)
+        
+        # Set fixed size
+        self.setFixedSize(400, 300)
+        
+        # Center the splash screen on the screen
+        screen_geometry = self.screen().geometry()
+        self.move(
+            (screen_geometry.width() - self.width()) // 2,
+            (screen_geometry.height() - self.height()) // 2
+        )
+
+        # Create movie label first (background)
+        self.movie_label = QLabel(self)
+        self.movie_label.setGeometry(0, 0, self.width(), self.height())
+        
+        # Create overlay for fade effect (between movie and content)
+        self.overlay = QLabel(self)
+        self.overlay.setStyleSheet("background-color: rgba(0, 0, 0, 0);")
+        self.overlay.setGeometry(0, 0, self.width(), self.height())
+        
+        # Create text label for animated text
+        self.text_label = QLabel(self)
+        self.text_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.text_label.setStyleSheet("color: rgba(255, 255, 255, 0); background: transparent;")
+        self.text_label.setGeometry(0, 0, self.width(), self.height())
+
+        # Create layout
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(20, 140, 20, 20)  # Increased top margin to accommodate title bar and logo
+        layout.setSpacing(10)
+        
+        # Create background container for the subtitle
+        self.content_container = QWidget(self)
+        self.content_container.setStyleSheet("background: transparent;")
+        content_layout = QVBoxLayout(self.content_container)
+        content_layout.setContentsMargins(20, 5, 20, 20)
+        content_layout.setSpacing(5)
+        
+        # Create subtitle label
+        self.subtitle_label = QLabel("Loading...", self.content_container)
+        self.subtitle_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.subtitle_label.setStyleSheet("""
+            QLabel {
+                color: #2C3E50;
+                font-size: 16px;
+                font-family: 'Segoe UI', Arial, sans-serif;
+                background: transparent;
+            }
+        """)
+        content_layout.addWidget(self.subtitle_label)
+        
+        # Add content container to main layout
+        layout.addWidget(self.content_container)
+        
+        # Create progress bar (always on top)
+        self.progress_bar = QLabel(self)
+        self.progress_bar.setFixedHeight(4)
+        self.progress_bar.setStyleSheet("background-color: #3498DB; border-radius: 2px;")
+        self.progress_bar.move(100, self.height() - 40)
+        self.progress_bar.setFixedWidth(0)
+
+        # Create a top overlay widget that will always be on top
+        self.top_overlay = QWidget(self)
+        self.top_overlay.setGeometry(0, 0, self.width(), 130)  # Covers title and logo area
+        self.top_overlay.setStyleSheet("background: transparent;")
+        
+        # Now create the top title and logo elements on the overlay
+        
+        # Create title bar at the very top
+        self.title_bar = QLabel(self.top_overlay)
+        self.title_bar.setText("SQL Shell")  # Set the text
+        self.title_bar.setFixedSize(self.width(), 50)
+        self.title_bar.move(0, 0)
+        self.title_bar.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.title_bar.setStyleSheet("""
+            QLabel {
+                color: white;
+                font-size: 28px;
+                font-weight: bold;
+                font-family: 'Segoe UI', Arial, sans-serif;
+                background-color: rgba(52, 152, 219, 0.9);
+                border-bottom: 2px solid #2980B9;
+                border-top-left-radius: 10px;
+                border-top-right-radius: 10px;
+            }
+        """)
+        
+        # Create a dedicated logo container right below the title bar
+        self.logo_container = QLabel(self.top_overlay)
+        self.logo_container.setFixedSize(self.width(), 80)
+        self.logo_container.move(0, 50)  # Position right below title bar
+        self.logo_container.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.logo_container.setStyleSheet("background: rgba(255, 255, 255, 0.8); border: 0px;")
+        
+        # Try to load logo directly here
+        logo_path = os.path.join(os.path.dirname(__file__), "resources", "logo_medium.png")
+        if os.path.exists(logo_path):
+            logo_pixmap = QPixmap(logo_path)
+            # Scale logo to appropriate size
+            scaled_logo = logo_pixmap.scaledToWidth(200, Qt.TransformationMode.SmoothTransformation)
+            self.logo_container.setPixmap(scaled_logo)
+            print(f"Logo loaded with size: {scaled_logo.width()}x{scaled_logo.height()}")
+            print(f"Logo container geometry: {self.logo_container.geometry()}")
+        else:
+            print(f"Logo not found at path: {logo_path}")
+            # Try the small logo as fallback
+            logo_path = os.path.join(os.path.dirname(__file__), "resources", "logo_small.png")
+            if os.path.exists(logo_path):
+                logo_pixmap = QPixmap(logo_path)
+                scaled_logo = logo_pixmap.scaledToWidth(150, Qt.TransformationMode.SmoothTransformation)
+                self.logo_container.setPixmap(scaled_logo)
+                print(f"Fallback logo loaded with size: {scaled_logo.width()}x{scaled_logo.height()}")
+                print(f"Logo container geometry: {self.logo_container.geometry()}")
+        
+        print(f"Title bar geometry: {self.title_bar.geometry()}")
+        print(f"Title bar text: {self.title_bar.text()}")
+        print(f"Top overlay geometry: {self.top_overlay.geometry()}")
+        
+        # Set appropriate z-order of elements
+        self.movie_label.lower()  # Background at the very back
+        self.overlay.raise_()      # Overlay above background
+        self.text_label.raise_()   # Text above overlay
+        self.content_container.raise_()  # Content above text
+        self.progress_bar.raise_() # Progress bar on top
+        self.top_overlay.raise_()  # Top overlay with title and logo at the very top
+        
+        # Set up the loading animation - do it immediately in init
+        self.movie = None  # Initialize to None for safety
+        self.load_animation()
+        
+        # Set up fade animation
+        self.fade_anim = QPropertyAnimation(self, b"opacity")
+        self.fade_anim.setDuration(1000)
+        self.fade_anim.setStartValue(0.0)
+        self.fade_anim.setEndValue(1.0)
+        self.fade_anim.setEasingCurve(QEasingCurve.Type.InOutQuad)
+        
+        # Set up progress animation
+        self.progress_anim = QPropertyAnimation(self, b"progress")
+        self.progress_anim.setDuration(2000)
+        self.progress_anim.setStartValue(0.0)
+        self.progress_anim.setEndValue(1.0)
+        self.progress_anim.setEasingCurve(QEasingCurve.Type.InOutQuad)
+        
+        # Create a dedicated timer to ensure title and logo always stay on top
+        self.z_order_timer = QTimer(self)
+        self.z_order_timer.timeout.connect(self.ensure_top_elements_visible)
+        self.z_order_timer.start(50)  # Check every 50ms
+        
+        # Start animations after everything is initialized
+        QTimer.singleShot(100, self.start_animations)  # Small delay to ensure everything is ready
+
+    def load_animation(self):
+        """Load the splash screen animation"""
+        # Check multiple potential paths for the splash screen GIF
+        possible_paths = [
+            os.path.join(os.path.dirname(__file__), "resources", "splash_screen.gif"),
+            os.path.join(os.path.dirname(os.path.dirname(__file__)), "resources", "splash_screen.gif"),
+            os.path.join(os.path.dirname(__file__), "splash_screen.gif"),
+            os.path.abspath("sqlshell/resources/splash_screen.gif"),
+            os.path.abspath("resources/splash_screen.gif")
+        ]
+        
+        # Try each possible path
+        for path in possible_paths:
+            if os.path.exists(path):
+                print(f"Loading splash screen animation from: {path}")
+                try:
+                    self.movie = QMovie(path)
+                    self.movie.setCacheMode(QMovie.CacheMode.CacheAll)  # Cache all frames for smoother playback
+                    self.movie.setScaledSize(self.size())
+                    
+                    # Connect frameChanged signal to update the label
+                    self.movie.frameChanged.connect(self.update_frame)
+                    
+                    # Ensure the movie label is visible but below other elements
+                    self.movie_label.lower()
+                    self.movie_label.setStyleSheet("background: transparent;")
+                    
+                    # Set the movie to the label
+                    self.movie_label.setMovie(self.movie)
+                    
+                    # Test if the movie is valid
+                    if self.movie.isValid():
+                        print(f"Successfully loaded animation with {self.movie.frameCount()} frames")
+                        self.use_fallback = False
+                        
+                        # Create a timer to ensure animation updates
+                        self.animation_timer = QTimer(self)
+                        self.animation_timer.timeout.connect(self.update_animation)
+                        self.animation_timer.start(50)  # Update every 50ms
+                        
+                        # Force our top overlay to be visible
+                        self.top_overlay.raise_()
+                        
+                        return
+                    else:
+                        print(f"Warning: Animation file at {path} is not valid")
+                        self.use_fallback = True
+                except Exception as e:
+                    print(f"Error loading animation from {path}: {e}")
+        
+        # If we get here, no valid animation was found
+        print("No valid animation found, using fallback static splash screen")
+        self.use_fallback = True
+
+    def update_frame(self):
+        """Handle frame changed in the animation"""
+        # Make sure the movie label is refreshed and visible
+        self.movie_label.update()
+        self.movie_label.show()
+        
+        # Always ensure title and logo stay on top
+        self.title_bar.raise_()
+        self.logo_container.raise_()
+        
+    def update_animation(self):
+        """Ensure animation keeps running"""
+        if self.movie and not self.use_fallback:
+            # Check if movie is running
+            if self.movie.state() != QMovie.MovieState.Running:
+                self.movie.start()
+            
+            # Force update of the movie label
+            self.movie_label.update()
+            
+            # Always ensure title and logo stay on top
+            self.title_bar.raise_()
+            self.logo_container.raise_()
+
+    def paintEvent(self, event):
+        """Custom paint event to draw a fallback splash screen if needed"""
+        if self.use_fallback:
+            painter = QPainter(self)
+            painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+            
+            # Draw rounded rectangle background
+            gradient = QLinearGradient(0, 0, 0, self.height())
+            gradient.setColorAt(0, QColor(44, 62, 80))   # Dark blue-gray
+            gradient.setColorAt(1, QColor(52, 152, 219)) # Bright blue
+            
+            painter.setBrush(gradient)
+            painter.setPen(Qt.PenStyle.NoPen)
+            painter.drawRoundedRect(0, 0, self.width(), self.height(), 10, 10)
+            
+            # Draw title bar at the top
+            title_rect = QRect(0, 0, self.width(), 50)
+            painter.setBrush(QColor(52, 152, 219))  # Bright blue
+            painter.drawRect(title_rect)
+            
+            # Draw title text
+            painter.setPen(QColor(255, 255, 255))
+            font = QFont("Segoe UI", 24)
+            font.setBold(True)
+            painter.setFont(font)
+            painter.drawText(title_rect, Qt.AlignmentFlag.AlignCenter, "SQL Shell")
+            
+            # Try to draw logo
+            logo_path = os.path.join(os.path.dirname(__file__), "resources", "logo_small.png")
+            if os.path.exists(logo_path):
+                logo_pixmap = QPixmap(logo_path)
+                scaled_logo = logo_pixmap.scaledToHeight(70, Qt.TransformationMode.SmoothTransformation)
+                logo_x = (self.width() - scaled_logo.width()) // 2
+                painter.drawPixmap(logo_x, 60, scaled_logo)
+            
+            # Draw progress bar
+            if hasattr(self, '_progress'):
+                progress_width = int(200 * self._progress)
+                progress_rect = QRect(100, self.height() - 40, progress_width, 4)
+                painter.setBrush(QColor(26, 188, 156))  # Teal
+                painter.drawRoundedRect(progress_rect, 2, 2)
+        
+        super().paintEvent(event)
+
+    def start_animations(self):
+        """Start all animations"""
+        # Try to start the movie if we have one
+        if self.movie and not self.use_fallback:
+            self.movie.start()
+            
+            # Check if movie is running after attempt to start
+            if not self.movie.state() == QMovie.MovieState.Running:
+                print("Warning: Could not start the animation")
+                self.use_fallback = True
+            else:
+                # Ensure the movie label is visible and updated
+                self.movie_label.show()
+                self.movie_label.update()
+                
+        self.fade_anim.start()
+        self.progress_anim.start()
+        self.progress_anim.finished.connect(self._on_animation_finished)
+
+    @pyqtProperty(float)
+    def opacity(self):
+        return self._opacity
+
+    @opacity.setter
+    def opacity(self, value):
+        self._opacity = value
+        # Update opacity of overlay and text
+        self.overlay.setStyleSheet(f"background-color: rgba(0, 0, 0, {int(100 * value)});")
+        self.text_label.setStyleSheet(f"""
+            QLabel {{
+                color: rgba(255, 255, 255, {int(255 * value)});
+                background: transparent;
+                text-shadow: 2px 2px 4px rgba(0, 0, 0, {int(180 * value)}),
+                            0px 0px 10px rgba(52, 152, 219, {int(160 * value)});
+            }}
+        """)
+
+    @pyqtProperty(float)
+    def progress(self):
+        return self._progress
+
+    @progress.setter
+    def progress(self, value):
+        self._progress = value
+        # Update progress bar width
+        if hasattr(self, 'progress_bar'):
+            self.progress_bar.setFixedWidth(int(200 * value))
+        # Force repaint if using fallback
+        if self.use_fallback:
+            self.update()
+
+    def ensure_top_elements_visible(self):
+        """Ensure title bar and logo container are always on top"""
+        self.top_overlay.raise_()
+        
+    def _on_animation_finished(self):
+        """Handle animation completion"""
+        if self.next_widget:
+            QTimer.singleShot(500, self._finish_splash)
+
+    def _finish_splash(self):
+        """Clean up and show the main window"""
+        # Stop the animation timer if it exists
+        if hasattr(self, 'animation_timer') and self.animation_timer:
+            self.animation_timer.stop()
+            
+        # Stop the z-order timer
+        if hasattr(self, 'z_order_timer'):
+            self.z_order_timer.stop()
+            
+        if self.movie:
+            self.movie.stop()
+        if self.fade_anim:
+            self.fade_anim.stop()
+        if self.progress_anim:
+            self.progress_anim.stop()
+        self.close()
+        if self.next_widget:
+            self.next_widget.show()
+
+    def finish(self, widget):
+        """Store the widget to show after animation completes"""
+        self.next_widget = widget
+        
+        # On Windows, we need to explicitly trigger the finish process
+        # instead of waiting for the animation to complete
+        
+        # First forcibly stop all animations
+        if hasattr(self, 'animation_timer') and self.animation_timer:
+            self.animation_timer.stop()
+            
+        # Stop the z-order timer
+        if hasattr(self, 'z_order_timer'):
+            self.z_order_timer.stop()
+            
+        if self.movie:
+            self.movie.stop()
+        if self.fade_anim:
+            self.fade_anim.stop()
+        if self.progress_anim:
+            self.progress_anim.stop()
+            
+        # Close the splash screen and show the main window directly
+        # Use a very short timer to allow the event loop to process
+        QTimer.singleShot(50, self._finish_splash) 

sqlshell/sqlshell/__init__.py

@@ -0,0 +1,5 @@
+"""
+SQLShell - A powerful SQL shell with GUI interface for data analysis
+"""
+
+__version__ = "0.1.1" 

sqlshell/sqlshell/create_test_data.py

@@ -0,0 +1,118 @@
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+import os
+
+# Set random seed for reproducibility
+np.random.seed(42)
+
+# Define output directory
+OUTPUT_DIR = 'test_data'
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+def create_sales_data(num_records=1000):
+    # Generate dates for the last 365 days
+    end_date = datetime.now()
+    start_date = end_date - timedelta(days=365)
+    dates = [start_date + timedelta(days=x) for x in range(366)]
+    random_dates = np.random.choice(dates, num_records)
+
+    # Create product data
+    products = ['Laptop', 'Smartphone', 'Tablet', 'Monitor', 'Keyboard', 'Mouse', 'Headphones', 'Printer']
+    product_prices = {
+        'Laptop': (800, 2000),
+        'Smartphone': (400, 1200),
+        'Tablet': (200, 800),
+        'Monitor': (150, 500),
+        'Keyboard': (20, 150),
+        'Mouse': (10, 80),
+        'Headphones': (30, 300),
+        'Printer': (100, 400)
+    }
+
+    # Generate random data
+    data = {
+        'OrderID': range(1, num_records + 1),
+        'Date': random_dates,
+        'ProductID': np.random.randint(1, len(products) + 1, num_records),  # Changed to ProductID for joining
+        'Quantity': np.random.randint(1, 11, num_records),
+        'CustomerID': np.random.randint(1, 201, num_records),
+        'Region': np.random.choice(['North', 'South', 'East', 'West'], num_records)
+    }
+
+    # Calculate prices based on product
+    product_list = [products[pid-1] for pid in data['ProductID']]
+    data['Price'] = [np.random.uniform(product_prices[p][0], product_prices[p][1]) 
+                     for p in product_list]
+    data['TotalAmount'] = [price * qty for price, qty in zip(data['Price'], data['Quantity'])]
+
+    # Create DataFrame
+    df = pd.DataFrame(data)
+
+    # Round numerical columns
+    df['Price'] = df['Price'].round(2)
+    df['TotalAmount'] = df['TotalAmount'].round(2)
+
+    # Sort by Date
+    return df.sort_values('Date')
+
+def create_customer_data(num_customers=200):
+    # Generate customer data
+    data = {
+        'CustomerID': range(1, num_customers + 1),
+        'FirstName': [f'Customer{i}' for i in range(1, num_customers + 1)],
+        'LastName': [f'Lastname{i}' for i in range(1, num_customers + 1)],
+        'Email': [f'customer{i}@example.com' for i in range(1, num_customers + 1)],
+        'JoinDate': [datetime.now() - timedelta(days=np.random.randint(1, 1000)) 
+                     for _ in range(num_customers)],
+        'CustomerType': np.random.choice(['Regular', 'Premium', 'VIP'], num_customers),
+        'CreditScore': np.random.randint(300, 851, num_customers)
+    }
+    
+    return pd.DataFrame(data)
+
+def create_product_data():
+    # Create detailed product information
+    products = {
+        'ProductID': range(1, 9),
+        'ProductName': ['Laptop', 'Smartphone', 'Tablet', 'Monitor', 'Keyboard', 'Mouse', 'Headphones', 'Printer'],
+        'Category': ['Computers', 'Mobile', 'Mobile', 'Accessories', 'Accessories', 'Accessories', 'Audio', 'Peripherals'],
+        'Brand': ['TechPro', 'MobileX', 'TabletCo', 'ViewMax', 'TypeMaster', 'ClickPro', 'SoundMax', 'PrintPro'],
+        'StockQuantity': np.random.randint(50, 500, 8),
+        'MinPrice': [800, 400, 200, 150, 20, 10, 30, 100],
+        'MaxPrice': [2000, 1200, 800, 500, 150, 80, 300, 400],
+        'Weight_kg': [2.5, 0.2, 0.5, 3.0, 0.8, 0.1, 0.3, 5.0],
+        'WarrantyMonths': [24, 12, 12, 36, 12, 12, 24, 12]
+    }
+    
+    return pd.DataFrame(products)
+
+if __name__ == '__main__':
+    # Create and save sales data
+    sales_df = create_sales_data()
+    sales_output = os.path.join(OUTPUT_DIR, 'sample_sales_data.xlsx')
+    sales_df.to_excel(sales_output, index=False)
+    print(f"Created sales data in '{sales_output}'")
+    print(f"Number of sales records: {len(sales_df)}")
+    
+    # Create and save customer data as parquet
+    customer_df = create_customer_data()
+    customer_output = os.path.join(OUTPUT_DIR, 'customer_data.parquet')
+    customer_df.to_parquet(customer_output, index=False)
+    print(f"\nCreated customer data in '{customer_output}'")
+    print(f"Number of customers: {len(customer_df)}")
+    
+    # Create and save product data
+    product_df = create_product_data()
+    product_output = os.path.join(OUTPUT_DIR, 'product_catalog.xlsx')
+    product_df.to_excel(product_output, index=False)
+    print(f"\nCreated product catalog in '{product_output}'")
+    print(f"Number of products: {len(product_df)}")
+    
+    # Print sample queries
+    print("\nSample SQL queries")
+    print("""
+    select * from product_catalog;
+    select * from customer_data;
+    select * from sample_sales_data;
+    """) 

sqlshell/sqlshell/create_test_databases.py

@@ -0,0 +1,96 @@
+import pandas as pd
+import sqlite3
+import duckdb
+import os
+
+# Define paths
+TEST_DATA_DIR = 'test_data'
+SQLITE_DB_PATH = os.path.join(TEST_DATA_DIR, 'test.db')
+DUCKDB_PATH = os.path.join(TEST_DATA_DIR, 'test.duckdb')
+
+def load_source_data():
+    """Load the source Excel and Parquet files."""
+    sales_df = pd.read_excel(os.path.join(TEST_DATA_DIR, 'sample_sales_data.xlsx'))
+    customer_df = pd.read_parquet(os.path.join(TEST_DATA_DIR, 'customer_data.parquet'))
+    product_df = pd.read_excel(os.path.join(TEST_DATA_DIR, 'product_catalog.xlsx'))
+    return sales_df, customer_df, product_df
+
+def create_sqlite_database():
+    """Create SQLite database with the test data."""
+    # Remove existing database if it exists
+    if os.path.exists(SQLITE_DB_PATH):
+        os.remove(SQLITE_DB_PATH)
+    
+    # Load data
+    sales_df, customer_df, product_df = load_source_data()
+    
+    # Create connection and write tables
+    with sqlite3.connect(SQLITE_DB_PATH) as conn:
+        sales_df.to_sql('sales', conn, index=False)
+        customer_df.to_sql('customers', conn, index=False)
+        product_df.to_sql('products', conn, index=False)
+        
+        # Create indexes for better performance
+        conn.execute('CREATE INDEX idx_sales_customer ON sales(CustomerID)')
+        conn.execute('CREATE INDEX idx_sales_product ON sales(ProductID)')
+    
+    print(f"Created SQLite database at {SQLITE_DB_PATH}")
+
+def create_duckdb_database():
+    """Create DuckDB database with the test data."""
+    # Remove existing database if it exists
+    if os.path.exists(DUCKDB_PATH):
+        os.remove(DUCKDB_PATH)
+    
+    # Load data
+    sales_df, customer_df, product_df = load_source_data()
+    
+    # Create connection and write tables
+    with duckdb.connect(DUCKDB_PATH) as conn:
+        conn.execute("CREATE TABLE sales AS SELECT * FROM sales_df")
+        conn.execute("CREATE TABLE customers AS SELECT * FROM customer_df")
+        conn.execute("CREATE TABLE products AS SELECT * FROM product_df")
+        
+        # Create indexes for better performance
+        conn.execute('CREATE INDEX idx_sales_customer ON sales(CustomerID)')
+        conn.execute('CREATE INDEX idx_sales_product ON sales(ProductID)')
+    
+    print(f"Created DuckDB database at {DUCKDB_PATH}")
+
+def verify_databases():
+    """Verify the databases were created correctly by running test queries."""
+    # Test SQLite
+    with sqlite3.connect(SQLITE_DB_PATH) as conn:
+        sales_count = pd.read_sql("SELECT COUNT(*) as count FROM sales", conn).iloc[0]['count']
+        print(f"\nSQLite verification:")
+        print(f"Sales records: {sales_count}")
+        
+        # Test a join query
+        sample_query = """
+        SELECT 
+            p.Category,
+            COUNT(*) as NumOrders,
+            ROUND(SUM(s.TotalAmount), 2) as TotalRevenue
+        FROM sales s
+        JOIN products p ON s.ProductID = p.ProductID
+        GROUP BY p.Category
+        LIMIT 3
+        """
+        print("\nSample SQLite query result:")
+        print(pd.read_sql(sample_query, conn))
+    
+    # Test DuckDB
+    with duckdb.connect(DUCKDB_PATH) as conn:
+        sales_count = conn.execute("SELECT COUNT(*) as count FROM sales").fetchone()[0]
+        print(f"\nDuckDB verification:")
+        print(f"Sales records: {sales_count}")
+        
+        # Test the same join query
+        print("\nSample DuckDB query result:")
+        print(conn.execute(sample_query).df())
+
+if __name__ == '__main__':
+    print("Creating test databases...")
+    create_sqlite_database()
+    create_duckdb_database()
+    verify_databases()