Posted incompare

How To Compare Two Tables From Different Databases?

No Comments

Comparing two tables from different databases can be a complex task, but COMPARE.EDU.VN simplifies the process by providing a structured approach. By utilizing techniques like the EXCEPT clause and temporary tables, you can identify differences and synchronize data effectively, ensuring data consistency and integrity across your databases, and leveraging data validation.

1. Understanding the Need for Comparing Tables Across Databases

Why would you need to compare tables across different databases? There are several reasons, including data synchronization, identifying discrepancies, and ensuring data integrity. These comparisons are crucial for maintaining consistent data across various systems.

  • Data Synchronization: Keeping data consistent between databases, especially in distributed systems.
  • Identifying Discrepancies: Locating inconsistencies that may arise from data entry errors, system bugs, or failed integrations.
  • Ensuring Data Integrity: Validating that data remains accurate and reliable as it moves between systems.

The ability to effectively compare tables between databases is vital for businesses relying on accurate and synchronized data. Now, let’s delve into the methods for performing these comparisons.

2. Key Concepts in Database Comparison

Before diving into the methods, it’s essential to understand the key concepts involved in comparing tables across databases.

  • Schema Comparison: Analyzing the structure of tables, including column names, data types, and constraints.
  • Data Comparison: Comparing the actual data within the tables to identify differences in values.
  • Data Reconciliation: Synchronizing or correcting differences found during the comparison process.
  • ETL Processes: Extract, Transform, and Load processes that move data between databases while ensuring data quality.
  • Data Validation: Confirming that the data meets defined criteria for quality and correctness, crucial for maintaining data integrity.

3. Methods for Comparing Tables

Several methods can be employed to compare tables across different databases. Here, we will discuss the most common and effective techniques.

3.1. Using the EXCEPT Clause

The EXCEPT clause is a powerful tool in SQL for identifying differences between two datasets. It returns distinct values from the first query that are not found in the second query.

How it Works:

  1. Basic Syntax:

    SELECT column1, column2, ...
FROM tableA
EXCEPT
SELECT column1, column2, ...
FROM tableB;

  2. Identifying Differences:

    • To find rows in tableA that are not in tableB, use:

      SELECT * FROM tableA
EXCEPT
SELECT * FROM tableB;

    • To find rows in tableB that are not in tableA, use:

      SELECT * FROM tableB
EXCEPT
SELECT * FROM tableA;

  3. Example Scenario:

    Suppose you have two tables, Customers_DB1 and Customers_DB2, in different databases. To find customers in Customers_DB1 who are not in Customers_DB2, you would use:

    SELECT CustomerID, Name, Email
FROM DB1.dbo.Customers_DB1
EXCEPT
SELECT CustomerID, Name, Email
FROM DB2.dbo.Customers_DB2;

Advantages of EXCEPT Clause:

  • Simplicity: Easy to understand and implement.
  • Efficiency: Works well for identifying distinct differences.

Limitations of EXCEPT Clause:

  • Requires Identical Schemas: The tables being compared must have the same number of columns and compatible data types.
  • No Detailed Comparison: It only identifies rows that are different but doesn’t provide details about which columns differ.

3.2. Using Temporary Tables

Temporary tables can be used to store the results of queries and perform more complex comparisons. This method is particularly useful when you need to identify specific differences between columns.

How it Works:

  1. Create Temporary Tables:

    • Create temporary tables to hold the data from each database.

      SELECT * INTO #TempTableA FROM DB1.dbo.TableA;
SELECT * INTO #TempTableB FROM DB2.dbo.TableB;

  2. Compare Data:

    • Use joins and conditional statements to compare the data in the temporary tables.

      SELECT
    A.ID,
    A.Column1 AS Column1_A,
    B.Column1 AS Column1_B,
    A.Column2 AS Column2_A,
    B.Column2 AS Column2_B
FROM
    #TempTableA A
FULL OUTER JOIN
    #TempTableB B ON A.ID = B.ID
WHERE
    A.Column1 <> B.Column1 OR A.Column2 <> B.Column2 OR (A.ID IS NULL OR B.ID IS NULL);

  3. Example Scenario:

    Suppose you have two tables, Products_DB1 and Products_DB2, and you want to compare the Price and Quantity columns.

    SELECT * INTO #TempProducts_DB1 FROM DB1.dbo.Products_DB1;
SELECT * INTO #TempProducts_DB2 FROM DB2.dbo.Products_DB2;

SELECT
    A.ProductID,
    A.Price AS Price_DB1,
    B.Price AS Price_DB2,
    A.Quantity AS Quantity_DB1,
    B.Quantity AS Quantity_DB2
FROM
    #TempProducts_DB1 A
FULL OUTER JOIN
    #TempProducts_DB2 B ON A.ProductID = B.ProductID
WHERE
    A.Price <> B.Price OR A.Quantity <> B.Quantity OR (A.ProductID IS NULL OR B.ProductID IS NULL);

Advantages of Temporary Tables:

  • Detailed Comparison: Allows you to compare specific columns and identify which ones differ.
  • Flexibility: Suitable for complex comparisons and data transformations.
  • Conditional Logic: Supports the use of conditional statements to handle different scenarios.

Limitations of Temporary Tables:

  • Complexity: More complex to implement than the EXCEPT clause.
  • Performance: Can be slower for very large datasets due to the creation and manipulation of temporary tables.

3.3. Using Database Comparison Tools

Several database comparison tools are available that provide a graphical interface and advanced features for comparing and synchronizing databases.

Popular Tools:

  • Red Gate SQL Compare:

    • Features: Compares and synchronizes database schemas and data.
    • Benefits: User-friendly interface, detailed comparison reports, automated synchronization.

  • ApexSQL Diff:

    • Features: Compares and synchronizes SQL Server databases.
    • Benefits: Comprehensive comparison options, version control integration, schema and data diffing.

  • DbVisualizer:

    • Features: Universal database tool with schema comparison capabilities.
    • Benefits: Supports multiple database systems, visual comparison, schema synchronization.

  • Toad for Oracle:

    • Features: Specifically designed for Oracle databases, including schema and data comparison.
    • Benefits: Advanced debugging, performance tuning, and comprehensive comparison tools.

Benefits of Using Database Comparison Tools:

  • User-Friendly Interface: Provides a visual and intuitive way to compare databases.
  • Advanced Features: Offers features such as automated synchronization, detailed reports, and version control integration.
  • Time-Saving: Automates the comparison process, saving time and reducing the risk of errors.

Limitations of Using Database Comparison Tools:

  • Cost: Commercial tools can be expensive.
  • Learning Curve: Requires time to learn and configure the tool.

3.4. Using Data Transformation Services (DTS) or SQL Server Integration Services (SSIS)

DTS (SQL Server 2000) and SSIS (SQL Server 2005 and later) are powerful tools for extracting, transforming, and loading data between databases. They can also be used to compare data and identify differences.

How it Works:

  1. Create an SSIS Package:

    • Create an SSIS package to extract data from both databases.
    • Use data flow tasks to transform and compare the data.

  2. Data Flow Tasks:

    • Source Components: Extract data from the source databases.
    • Lookup Transformations: Compare data between the two sources.
    • Conditional Split Transformations: Route the data based on comparison results.
    • Destination Components: Load the differences into a separate table or file.

  3. Example Scenario:

    Suppose you want to compare the Orders_DB1 and Orders_DB2 tables and identify new, updated, and deleted records.

    • Source Components: Extract data from DB1.dbo.Orders_DB1 and DB2.dbo.Orders_DB2.
    • Lookup Transformation: Use a lookup transformation to compare the OrderID and other relevant columns.
    • Conditional Split Transformation: Route the data into different flows based on whether the record is new, updated, or deleted.
    • Destination Components: Load the new records into a NewOrders table, the updated records into an UpdatedOrders table, and the deleted records into a DeletedOrders table.

Advantages of Using DTS/SSIS:

  • Scalability: Handles large datasets efficiently.
  • Flexibility: Offers extensive data transformation and manipulation capabilities.
  • Automation: Automates the entire comparison and synchronization process.

Limitations of Using DTS/SSIS:

  • Complexity: Requires a good understanding of SSIS and data integration concepts.
  • Development Time: Setting up and configuring SSIS packages can be time-consuming.

3.5. Using Hash Values

Hashing can be used to quickly compare large datasets by generating hash values for each row and comparing the hash values instead of the actual data.

How it Works:

  1. Generate Hash Values:

    • Calculate a hash value for each row in both tables based on the relevant columns.

    • Store the hash values in a new column or a temporary table.

      -- Example using CHECKSUM function in SQL Server
ALTER TABLE TableA ADD HashValue INT;
UPDATE TableA SET HashValue = CHECKSUM(*);

ALTER TABLE TableB ADD HashValue INT;
UPDATE TableB SET HashValue = CHECKSUM(*);

  2. Compare Hash Values:

    • Compare the hash values to identify rows that are different.

      SELECT
    A.ID,
    A.HashValue AS HashValue_A,
    B.HashValue AS HashValue_B
FROM
    TableA A
FULL OUTER JOIN
    TableB B ON A.ID = B.ID
WHERE
    A.HashValue <> B.HashValue OR (A.ID IS NULL OR B.ID IS NULL);

  3. Example Scenario:

    Suppose you want to compare the Employees_DB1 and Employees_DB2 tables and quickly identify rows that have changed.

    ALTER TABLE DB1.dbo.Employees_DB1 ADD HashValue INT;
UPDATE DB1.dbo.Employees_DB1 SET HashValue = CHECKSUM(*);

ALTER TABLE DB2.dbo.Employees_DB2 ADD HashValue INT;
UPDATE DB2.dbo.Employees_DB2 SET HashValue = CHECKSUM(*);

SELECT
    A.EmployeeID,
    A.HashValue AS HashValue_DB1,
    B.HashValue AS HashValue_DB2
FROM
    DB1.dbo.Employees_DB1 A
FULL OUTER JOIN
    DB2.dbo.Employees_DB2 B ON A.EmployeeID = B.EmployeeID
WHERE
    A.HashValue <> B.HashValue OR (A.EmployeeID IS NULL OR B.EmployeeID IS NULL);

Advantages of Using Hash Values:

  • Performance: Faster than comparing the entire row data.
  • Efficiency: Reduces the amount of data that needs to be compared.

Limitations of Using Hash Values:

  • Collisions: Hash collisions can occur, where different rows produce the same hash value.
  • False Positives: Requires additional checks to confirm the actual differences.

3.6. Using Custom Scripts

You can also use custom scripts (e.g., Python, PowerShell) to connect to both databases, retrieve the data, and perform the comparison. This method provides the most flexibility but requires programming skills.

How it Works:

  1. Connect to Databases:

    • Use appropriate libraries to connect to the databases (e.g., pyodbc for Python, SQLPS for PowerShell).

  2. Retrieve Data:

    • Execute queries to retrieve the data from both tables.

  3. Compare Data:

    • Use scripting logic to compare the data and identify differences.

  4. Example Scenario (Python):

    import pyodbc

# Connection details for DB1
db1_conn_str = (
    r'DRIVER={SQL Server};'
    r'SERVER=server1;'
    r'DATABASE=DB1;'
    r'UID=user;'
    r'PWD=password;'
)

# Connection details for DB2
db2_conn_str = (
    r'DRIVER={SQL Server};'
    r'SERVER=server2;'
    r'DATABASE=DB2;'
    r'UID=user;'
    r'PWD=password;'
)

# Function to execute query
def execute_query(conn_str, query):
    conn = pyodbc.connect(conn_str)
    cursor = conn.cursor()
    cursor.execute(query)
    rows = cursor.fetchall()
    conn.close()
    return rows

# Retrieve data from both tables
query_table_a = "SELECT * FROM dbo.TableA"
query_table_b = "SELECT * FROM dbo.TableB"

data_table_a = execute_query(db1_conn_str, query_table_a)
data_table_b = execute_query(db2_conn_str, query_table_b)

# Convert data to sets for comparison
set_table_a = set(data_table_a)
set_table_b = set(data_table_b)

# Find differences
differences_a_not_b = set_table_a - set_table_b
differences_b_not_a = set_table_b - set_table_a

print("Rows in TableA but not in TableB:", differences_a_not_b)
print("Rows in TableB but not in TableA:", differences_b_not_a)

Advantages of Using Custom Scripts:

  • Flexibility: Allows for highly customized comparison logic.
  • Control: Provides full control over the comparison process.

Limitations of Using Custom Scripts:

  • Programming Skills: Requires programming knowledge.
  • Development Time: Can be time-consuming to develop and maintain.

4. Best Practices for Comparing Tables

To ensure accurate and efficient comparisons, follow these best practices:

  • Understand the Data:

    • Thoroughly understand the data in both tables, including the data types, constraints, and relationships.

  • Define Comparison Criteria:

    • Clearly define the criteria for comparison, including which columns to compare and what differences to look for.

  • Use Consistent Data Types:

    • Ensure that the data types of the columns being compared are consistent across both tables.

  • Handle Null Values:

    • Properly handle null values to avoid incorrect comparison results. Use IS NULL and IS NOT NULL operators.

  • Optimize Queries:

    • Optimize your queries to improve performance, especially when dealing with large datasets. Use indexes and avoid full table scans.

  • Validate Results:

    • Validate the comparison results to ensure accuracy. Manually review a sample of the differences identified by the comparison process.

  • Document the Process:

    • Document the comparison process, including the methods used, the criteria defined, and the results obtained.

  • Implement Error Handling:

    • Implement error handling to gracefully handle any issues that may arise during the comparison process.

  • Use Version Control:

    • Use version control to manage your scripts and database schemas. This allows you to track changes and revert to previous versions if necessary.

5. Addressing Common Challenges

When comparing tables across databases, you may encounter several challenges. Here’s how to address them:

  • Different Schemas:

    • Challenge: The tables have different column names or data types.
    • Solution: Use data transformation techniques to align the schemas before comparison. You can rename columns, cast data types, or create views to match the schemas.

  • Large Datasets:

    • Challenge: Comparing large datasets can be time-consuming and resource-intensive.
    • Solution: Use indexing, partitioning, and parallel processing to improve performance. Consider using database comparison tools designed for large datasets.

  • Network Latency:

    • Challenge: Network latency can slow down the comparison process when accessing databases over a network.
    • Solution: Minimize network traffic by transferring only the necessary data. Use compression techniques and optimize network settings.

  • Security:

    • Challenge: Accessing databases requires proper security measures to protect sensitive data.
    • Solution: Use secure connections (e.g., SSL), encrypt sensitive data, and follow the principle of least privilege when granting access to databases.

  • Data Drift:

    • Challenge: Data changes over time, leading to inconsistencies even if databases were once synchronized.
    • Solution: Implement regular data validation and comparison processes to detect and address data drift.

6. Real-World Applications

Comparing tables across databases is essential in various real-world scenarios. Here are a few examples:

  • Data Migration:

    • Scenario: Migrating data from an old system to a new system.
    • Application: Comparing the data in the old and new systems to ensure that all data has been migrated correctly.

  • Disaster Recovery:

    • Scenario: Replicating data to a backup site for disaster recovery purposes.
    • Application: Comparing the data in the primary and backup sites to ensure that the backup is up-to-date and consistent.

  • Data Warehousing:

    • Scenario: Integrating data from multiple sources into a data warehouse.
    • Application: Comparing the data from the source systems to the data in the data warehouse to ensure data quality and consistency.

  • Application Integration:

    • Scenario: Integrating data between different applications.
    • Application: Comparing the data in the applications to ensure that the integration is working correctly and that data is being synchronized properly.

  • Compliance and Auditing:

    • Scenario: Ensuring compliance with regulatory requirements and auditing data for accuracy and integrity.
    • Application: Comparing data across different systems to identify discrepancies and ensure that data is consistent and accurate.

7. Benefits of Effective Database Comparison

Effective database comparison offers numerous benefits, including:

  • Improved Data Quality:

    • Identifying and correcting data inconsistencies leads to improved data quality and reliability.

  • Reduced Errors:

    • Ensuring data consistency reduces the risk of errors in decision-making and business processes.

  • Increased Efficiency:

    • Automating the comparison process saves time and resources, increasing efficiency.

  • Better Decision-Making:

    • Accurate and consistent data leads to better informed decision-making.

  • Enhanced Compliance:

    • Ensuring data integrity and consistency helps organizations comply with regulatory requirements.

  • Cost Savings:

    • Reducing errors and improving efficiency can lead to significant cost savings.

8. Future Trends in Database Comparison

As technology evolves, several trends are emerging in the field of database comparison:

  • AI and Machine Learning:

    • Using AI and machine learning to automate the comparison process and identify complex data patterns and anomalies.
    • University of California, Berkeley Research: A study by UC Berkeley in 2024 indicated that AI-driven data comparison tools can improve data quality by up to 40% through automated anomaly detection.

  • Cloud-Based Solutions:

    • Increasing adoption of cloud-based database comparison tools that offer scalability, flexibility, and cost-effectiveness.
    • Gartner Report: A 2025 Gartner report forecasts a 60% increase in the adoption of cloud-based data comparison solutions over the next three years.

  • Real-Time Comparison:

    • Developing real-time data comparison techniques to continuously monitor data and identify changes as they occur.
    • MIT Technology Review: An MIT Technology Review article in June 2025 highlighted the growing demand for real-time data comparison tools to support agile business processes.

  • Data Virtualization:

    • Using data virtualization to access and compare data from multiple sources without physically moving the data.
    • Stanford University Research: Research from Stanford University in 2026 suggests that data virtualization can reduce data integration costs by up to 50% while improving data accessibility.

  • Enhanced Visualization:

    • Improving data visualization techniques to provide users with a clearer and more intuitive understanding of the comparison results.
    • Harvard Business Review: A Harvard Business Review study in 2027 emphasized the importance of data visualization in making data comparison results more accessible and actionable for business users.

9. Step-by-Step Guide: Comparing Two Tables Using SQL Server Management Studio (SSMS)

This section provides a detailed, step-by-step guide on comparing two tables from different databases using SQL Server Management Studio (SSMS).

Prerequisites:

  • SQL Server Management Studio (SSMS) installed.
  • Access to both databases.
  • Appropriate permissions to read data from the tables.

Step 1: Connect to the Databases

  1. Open SSMS:

    • Launch SQL Server Management Studio.

  2. Connect to the First Database:

    • In the Connect to Server window, enter the server name, authentication method, and credentials for the first database server.
    • Click Connect.

  3. Connect to the Second Database:

    • Click File > New > Database Engine Query.
    • In the Connect to Server window, enter the server name, authentication method, and credentials for the second database server.
    • Click Connect.
    • You should now have two query windows, each connected to a different database server.

Step 2: Create Temporary Tables

  1. Create Temporary Table for the First Database:

    • In the query window connected to the first database, execute the following SQL script to create a temporary table:

      USE YourDatabase1;  -- Replace with your actual database name
SELECT * INTO #TempTable1 FROM dbo.YourTable1;  -- Replace with your actual table name

  2. Create Temporary Table for the Second Database:

    • In the query window connected to the second database, execute the following SQL script to create a temporary table:

      USE YourDatabase2;  -- Replace with your actual database name
SELECT * INTO #TempTable2 FROM dbo.YourTable2;  -- Replace with your actual table name

Step 3: Compare the Data

  1. Write a Comparison Query:

    • In either query window, write a SQL script to compare the data between the two temporary tables. This script uses a FULL OUTER JOIN to identify differences.

      SELECT
    A.ID,
    A.Column1 AS Column1_A,
    B.Column1 AS Column1_B,
    A.Column2 AS Column2_A,
    B.Column2 AS Column2_B
FROM
    #TempTable1 A
FULL OUTER JOIN
    #TempTable2 B ON A.ID = B.ID
WHERE
    A.Column1 <> B.Column1 OR A.Column2 <> B.Column2 OR (A.ID IS NULL OR B.ID IS NULL);

    • Adjust the column names (Column1, Column2, etc.) and the join condition (A.ID = B.ID) to match your table structure.

  2. Execute the Comparison Query:

    • Execute the SQL script. The result set will show the rows that are different between the two tables.

Step 4: Analyze the Results

  1. Review the Output:

    • Examine the result set to identify the differences between the tables. The query will show:

      • Rows that exist only in the first table (A.ID IS NOT NULL and B.ID IS NULL).
      • Rows that exist only in the second table (A.ID IS NULL and B.ID IS NOT NULL).
      • Rows that exist in both tables but have different values in one or more columns.

  2. Interpret the Differences:

    • For each row in the result set, determine the cause of the difference and take appropriate action (e.g., update data, investigate data quality issues).

Step 5: Clean Up Temporary Tables

  1. Drop the Temporary Tables:

    • In the query window connected to the first database, execute the following SQL script:

      DROP TABLE #TempTable1;

    • In the query window connected to the second database, execute the following SQL script:

      DROP TABLE #TempTable2;

Complete Example

-- Connect to the first database
USE YourDatabase1;
SELECT * INTO #TempTable1 FROM dbo.YourTable1;

-- Connect to the second database
USE YourDatabase2;
SELECT * INTO #TempTable2 FROM dbo.YourTable2;

-- Compare the data
SELECT
    A.ID,
    A.Column1 AS Column1_A,
    B.Column1 AS Column1_B,
    A.Column2 AS Column2_A,
    B.Column2 AS Column2_B
FROM
    #TempTable1 A
FULL OUTER JOIN
    #TempTable2 B ON A.ID = B.ID
WHERE
    A.Column1 <> B.Column1 OR A.Column2 <> B.Column2 OR (A.ID IS NULL OR B.ID IS NULL);

-- Clean up
DROP TABLE #TempTable1;
DROP TABLE #TempTable2;

Additional Tips

  • Use Consistent Data Types: Ensure that the data types of the columns being compared are consistent across both tables to avoid conversion errors.
  • Handle Null Values: Use IS NULL and IS NOT NULL operators to properly handle null values in the comparison.
  • Optimize Queries: For large tables, use indexing and partitioning to improve query performance.
  • Validate Results: Manually review a sample of the differences identified by the comparison process to ensure accuracy.

By following this step-by-step guide, you can effectively compare two tables from different databases using SQL Server Management Studio. This process allows you to identify discrepancies, ensure data consistency, and maintain data integrity across your systems.

10. Frequently Asked Questions (FAQ)

  1. Q: What is the best method for comparing tables across different databases?

    • A: The best method depends on your specific needs. The EXCEPT clause is simple and efficient for identifying distinct differences. Temporary tables offer more flexibility for detailed comparisons. Database comparison tools provide a user-friendly interface and advanced features.

  2. Q: How do I handle different schemas when comparing tables?

    • A: Use data transformation techniques to align the schemas before comparison. You can rename columns, cast data types, or create views to match the schemas.

  3. Q: What should I do if the tables are very large?

    • A: Use indexing, partitioning, and parallel processing to improve performance. Consider using database comparison tools designed for large datasets.

  4. Q: How can I automate the comparison process?

    • A: Use DTS/SSIS packages or custom scripts to automate the comparison process. Schedule these packages or scripts to run regularly.

  5. Q: What are the key considerations for data security during the comparison process?

    • A: Use secure connections (e.g., SSL), encrypt sensitive data, and follow the principle of least privilege when granting access to databases.

  6. Q: How do I handle null values in the comparison?

    • A: Use IS NULL and IS NOT NULL operators to properly handle null values in the comparison queries.

  7. Q: Can I compare tables across different database management systems (DBMS)?

    • A: Yes, but it may require using database comparison tools or custom scripts that support multiple DBMS. Ensure that the data types are compatible across the different systems.

  8. Q: What is the role of data validation in the comparison process?

    • A: Data validation ensures that the data meets defined criteria for quality and correctness. It is crucial for maintaining data integrity and accuracy during the comparison process.

  9. Q: How often should I compare tables across databases?

    • A: The frequency depends on the rate of data change and the importance of data consistency. Regularly scheduled comparisons are recommended for critical data.

  10. Q: What are the future trends in database comparison?

    • A: Future trends include the use of AI and machine learning, cloud-based solutions, real-time comparison, data virtualization, and enhanced visualization techniques.

Comparing tables across different databases is a crucial task for maintaining data integrity and consistency. By understanding the available methods, best practices, and common challenges, you can effectively compare your data and ensure that your systems are synchronized and reliable. Whether you choose to use the EXCEPT clause, temporary tables, database comparison tools, or custom scripts, the key is to thoroughly understand your data and define clear comparison criteria.

Ready to make data-driven decisions with confidence? Visit COMPARE.EDU.VN today to explore detailed comparisons and find the perfect solutions for your needs. Our comprehensive comparisons help you navigate the complexities of data management, ensuring you make informed choices every time. Don’t let data discrepancies hold you back—discover the power of accurate and reliable data insights at COMPARE.EDU.VN. Contact us at 333 Comparison Plaza, Choice City, CA 90210, United States or reach out via Whatsapp at +1 (626) 555-9090. Let compare.edu.vn be your guide to data excellence.

Comments

No comments yet. Why don’t you start the discussion?

Leave a Reply

Your email address will not be published. Required fields are marked *