Working with CSV Files: Import, Export, and Transform Data Like a Pro

name,email,age,city
John Doe,[email protected],30,New York
Jane Smith,[email protected],25,Los Angeles
Bob Johnson,[email protected],35,Chicago

# Comma-separated (standard)
name,age,city

# Semicolon-separated (European style)
name;age;city

# Tab-separated (TSV)
name	age	city

# Pipe-separated
name|age|city

name,description,price
"Standard Product","Simple item",29.99
"Premium Product","Item with, comma",49.99
"Deluxe Product","Item with ""quotes""",99.99
"Special Product","Multi-line
description",79.99

// Install: npm install papaparse
import Papa from 'papaparse';

// Parse CSV string
const csvString = `name,age,city
John Doe,30,New York
Jane Smith,25,LA`;

const result = Papa.parse(csvString, {
  header: true,           // First row is headers
  dynamicTyping: true,    // Convert numbers/booleans
  skipEmptyLines: true,   // Ignore empty lines
  transformHeader: (h) => h.trim().toLowerCase(),
  complete: function(results) {
    console.log('Parsed:', results.data);
    console.log('Errors:', results.errors);
  }
});

// Output:
// [
//   { name: 'John Doe', age: 30, city: 'New York' },
//   { name: 'Jane Smith', age: 25, city: 'LA' }
// ]

// Simple CSV parser (basic cases only)
function parseCSV(csvString) {
  const lines = csvString.trim().split('\n');
  const headers = lines[0].split(',').map(h => h.trim());

  return lines.slice(1).map(line => {
    const values = line.split(',').map(v => v.trim());
    return headers.reduce((obj, header, index) => {
      obj[header] = values[index];
      return obj;
    }, {});
  });
}

const csv = `name,age,city
John,30,NYC
Jane,25,LA`;

const data = parseCSV(csv);
console.log(data);
// [
//   { name: 'John', age: '30', city: 'NYC' },
//   { name: 'Jane', age: '25', city: 'LA' }
// ]

// Handle CSV file upload in browser
function handleFileUpload(event) {
  const file = event.target.files[0];

  Papa.parse(file, {
    header: true,
    dynamicTyping: true,
    encoding: 'UTF-8',
    skipEmptyLines: true,
    complete: function(results) {
      console.log('Total rows:', results.data.length);
      console.log('Data:', results.data);

      if (results.errors.length > 0) {
        console.error('Parsing errors:', results.errors);
      }
    },
    error: function(error) {
      console.error('File error:', error);
    }
  });
}

// HTML
// <input type="file" accept=".csv" onchange="handleFileUpload(event)">

import csv

# Reading CSV file
with open('data.csv', 'r', encoding='utf-8') as file:
    csv_reader = csv.DictReader(file)

    for row in csv_reader:
        print(f"{row['name']}: {row['age']} years old")

# Writing CSV file
data = [
    {'name': 'John Doe', 'age': 30, 'city': 'New York'},
    {'name': 'Jane Smith', 'age': 25, 'city': 'Los Angeles'}
]

with open('output.csv', 'w', newline='', encoding='utf-8') as file:
    fieldnames = ['name', 'age', 'city']
    csv_writer = csv.DictWriter(file, fieldnames=fieldnames)

    csv_writer.writeheader()
    csv_writer.writerows(data)

import pandas as pd

# Read CSV file
df = pd.read_csv('data.csv', encoding='utf-8')

# Display first few rows
print(df.head())

# Basic info
print(df.info())
print(df.describe())

# Filter data
adults = df[df['age'] >= 18]

# Sort data
sorted_df = df.sort_values('age', ascending=False)

# Export to CSV
df.to_csv('output.csv', index=False, encoding='utf-8')

import pandas as pd

# Advanced parsing options
df = pd.read_csv(
    'data.csv',
    sep=',',                    # Delimiter
    encoding='utf-8',           # Character encoding
    thousands=',',              # Thousands separator
    decimal='.',                # Decimal separator
    na_values=['N/A', 'NULL'],  # Null value markers
    dtype={'zip_code': str},    # Force column types
    parse_dates=['date_column'], # Parse dates
    converters={'phone': lambda x: x.strip()}, # Custom converters
    skiprows=[1, 2],            # Skip specific rows
    nrows=1000,                 # Read only N rows
    usecols=['name', 'age']     # Read specific columns only
)

# Handle missing data
df.fillna(0, inplace=True)      # Fill with value
df.dropna(inplace=True)         # Drop rows with NaN

# Data type conversion
df['age'] = pd.to_numeric(df['age'], errors='coerce')
df['date'] = pd.to_datetime(df['date'], format='%Y-%m-%d')

import pandas as pd

# Process large CSV in chunks
chunk_size = 10000
chunks = []

for chunk in pd.read_csv('large_file.csv', chunksize=chunk_size):
    # Process each chunk
    chunk_processed = chunk[chunk['age'] > 18]
    chunks.append(chunk_processed)

# Combine results
final_df = pd.concat(chunks, ignore_index=True)

# Alternative: Stream processing
with pd.read_csv('large_file.csv', chunksize=chunk_size) as reader:
    for chunk in reader:
        # Process chunk
        result = chunk.groupby('category').sum()
        print(result)

<?php
// Read CSV file
$file = fopen('data.csv', 'r');

// Get headers
$headers = fgetcsv($file);

// Read data
$data = [];
while (($row = fgetcsv($file)) !== false) {
    $data[] = array_combine($headers, $row);
}
fclose($file);

print_r($data);

// Write CSV file
$output = fopen('output.csv', 'w');

// Write headers
fputcsv($output, ['name', 'age', 'city']);

// Write data
$records = [
    ['John Doe', 30, 'New York'],
    ['Jane Smith', 25, 'Los Angeles']
];

foreach ($records as $record) {
    fputcsv($output, $record);
}
fclose($output);
?>

import org.apache.commons.csv.*;
import java.io.*;
import java.util.*;

public class CSVParser {
    public static void main(String[] args) throws IOException {
        // Read CSV
        Reader in = new FileReader("data.csv");
        Iterable<CSVRecord> records = CSVFormat.DEFAULT
            .withFirstRecordAsHeader()
            .parse(in);

        for (CSVRecord record : records) {
            String name = record.get("name");
            String age = record.get("age");
            System.out.println(name + ": " + age);
        }
        in.close();

        // Write CSV
        FileWriter out = new FileWriter("output.csv");
        CSVPrinter printer = new CSVPrinter(out, CSVFormat.DEFAULT
            .withHeader("name", "age", "city"));

        printer.printRecord("John Doe", 30, "New York");
        printer.printRecord("Jane Smith", 25, "Los Angeles");

        printer.flush();
        printer.close();
    }
}

using CsvHelper;
using System.Globalization;

// Read CSV
using (var reader = new StreamReader("data.csv"))
using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
{
    var records = csv.GetRecords<Person>();
    foreach (var record in records)
    {
        Console.WriteLine($"{record.Name}: {record.Age}");
    }
}

// Write CSV
var records = new List<Person>
{
    new Person { Name = "John Doe", Age = 30, City = "New York" },
    new Person { Name = "Jane Smith", Age = 25, City = "Los Angeles" }
};

using (var writer = new StreamWriter("output.csv"))
using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
{
    csv.WriteRecords(records);
}

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public string City { get; set; }
}

require 'csv'

# Read CSV
CSV.foreach('data.csv', headers: true) do |row|
  puts "#{row['name']}: #{row['age']} years old"
end

# Parse CSV string
csv_string = "name,age,city\nJohn Doe,30,New York"
data = CSV.parse(csv_string, headers: true)
data.each { |row| puts row['name'] }

# Write CSV
CSV.open('output.csv', 'w') do |csv|
  csv << ['name', 'age', 'city']
  csv << ['John Doe', 30, 'New York']
  csv << ['Jane Smith', 25, 'Los Angeles']
end

name,age,city
John Doe,30,New York
Jane Smith,25  # Missing city column - ERROR
Bob,35,Chicago,Extra  # Too many columns - ERROR

name,description
"John Doe","He said "hello"  # Unescaped quote - ERROR
"Jane Smith","She said ""hello""  # Correct escaping

name,age,city
John Doe,30,New York
Jane Smith;25;Los Angeles  # Wrong delimiter - ERROR

function validateCSV(data, schema) {
  const errors = [];

  // Check headers
  const expectedHeaders = Object.keys(schema);
  const actualHeaders = Object.keys(data[0] || {});

  const missingHeaders = expectedHeaders.filter(h => !actualHeaders.includes(h));
  if (missingHeaders.length > 0) {
    errors.push(`Missing headers: ${missingHeaders.join(', ')}`);
  }

  // Validate each row
  data.forEach((row, index) => {
    // Check column count
    if (Object.keys(row).length !== expectedHeaders.length) {
      errors.push(`Row ${index + 1}: Incorrect column count`);
    }

    // Validate data types and constraints
    Object.entries(schema).forEach(([field, rules]) => {
      const value = row[field];

      // Required field
      if (rules.required && !value) {
        errors.push(`Row ${index + 1}: ${field} is required`);
      }

      // Type validation
      if (value && rules.type === 'number' && isNaN(value)) {
        errors.push(`Row ${index + 1}: ${field} must be a number`);
      }

      if (value && rules.type === 'email' && !isValidEmail(value)) {
        errors.push(`Row ${index + 1}: ${field} is not a valid email`);
      }

      // Range validation
      if (rules.min !== undefined && value < rules.min) {
        errors.push(`Row ${index + 1}: ${field} below minimum ${rules.min}`);
      }

      if (rules.max !== undefined && value > rules.max) {
        errors.push(`Row ${index + 1}: ${field} exceeds maximum ${rules.max}`);
      }
    });
  });

  return {
    valid: errors.length === 0,
    errors
  };
}

// Usage
const schema = {
  name: { required: true, type: 'string' },
  age: { required: true, type: 'number', min: 0, max: 150 },
  email: { required: true, type: 'email' }
};

const validation = validateCSV(data, schema);
if (!validation.valid) {
  console.error('Validation errors:', validation.errors);
}

// Simple CSV to JSON
function csvToJson(csvString) {
  const lines = csvString.trim().split('\n');
  const headers = lines[0].split(',').map(h => h.trim());

  return lines.slice(1).map(line => {
    const values = line.split(',').map(v => v.trim());
    return headers.reduce((obj, header, i) => {
      obj[header] = values[i];
      return obj;
    }, {});
  });
}

// Using Papa Parse
import Papa from 'papaparse';

const csv = `name,age,city
John Doe,30,New York
Jane Smith,25,Los Angeles`;

const result = Papa.parse(csv, { header: true });
const jsonString = JSON.stringify(result.data, null, 2);
console.log(jsonString);

// Output:
// [
//   {
//     "name": "John Doe",
//     "age": "30",
//     "city": "New York"
//   },
//   {
//     "name": "Jane Smith",
//     "age": "25",
//     "city": "Los Angeles"
//   }
// ]

import csv
import json

# Method 1: Using csv module
def csv_to_json(csv_file, json_file):
    data = []

    with open(csv_file, 'r', encoding='utf-8') as f:
        csv_reader = csv.DictReader(f)
        for row in csv_reader:
            data.append(row)

    with open(json_file, 'w', encoding='utf-8') as f:
        json.dump(data, f, indent=2)

# Method 2: Using pandas
import pandas as pd

df = pd.read_csv('data.csv')
df.to_json('output.json', orient='records', indent=2)

# Pretty print
json_string = df.to_json(orient='records', indent=2)
print(json_string)

// Convert CSV to nested JSON structure
function csvToNestedJson(csvData, groupBy) {
  const result = {};

  csvData.forEach(row => {
    const key = row[groupBy];
    if (!result[key]) {
      result[key] = [];
    }

    const { [groupBy]: _, ...rest } = row;
    result[key].push(rest);
  });

  return result;
}

const csv = [
  { category: 'Electronics', name: 'Laptop', price: 999 },
  { category: 'Electronics', name: 'Phone', price: 599 },
  { category: 'Books', name: 'Novel', price: 15 }
];

const nested = csvToNestedJson(csv, 'category');
console.log(JSON.stringify(nested, null, 2));

// Output:
// {
//   "Electronics": [
//     { "name": "Laptop", "price": 999 },
//     { "name": "Phone", "price": 599 }
//   ],
//   "Books": [
//     { "name": "Novel", "price": 15 }
//   ]
// }

import pandas as pd
from openpyxl import Workbook
from openpyxl.styles import Font, PatternFill

# Method 1: Using pandas
df = pd.read_csv('data.csv')
df.to_excel('output.xlsx', index=False, sheet_name='Data')

# Method 2: Using openpyxl with formatting
wb = Workbook()
ws = wb.active
ws.title = 'Data'

# Read CSV
import csv
with open('data.csv', 'r') as f:
    csv_reader = csv.reader(f)

    for row_idx, row in enumerate(csv_reader, 1):
        for col_idx, value in enumerate(row, 1):
            cell = ws.cell(row=row_idx, column=col_idx, value=value)

            # Format header row
            if row_idx == 1:
                cell.font = Font(bold=True)
                cell.fill = PatternFill(start_color='CCCCCC',
                                       end_color='CCCCCC',
                                       fill_type='solid')

wb.save('formatted_output.xlsx')

// Using SheetJS (xlsx)
import * as XLSX from 'xlsx';
import Papa from 'papaparse';

// Parse CSV
const csvString = `name,age,city
John Doe,30,New York
Jane Smith,25,Los Angeles`;

const parsedData = Papa.parse(csvString, { header: true }).data;

// Create workbook
const wb = XLSX.utils.book_new();
const ws = XLSX.utils.json_to_sheet(parsedData);

// Add worksheet to workbook
XLSX.utils.book_append_sheet(wb, ws, 'Sheet1');

// Write to file (Node.js)
XLSX.writeFile(wb, 'output.xlsx');

// Or create blob for browser download
const excelBuffer = XLSX.write(wb, { bookType: 'xlsx', type: 'array' });
const blob = new Blob([excelBuffer], {
  type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
});

import csv
import xml.etree.ElementTree as ET

def csv_to_xml(csv_file, xml_file, root_name='data', record_name='record'):
    root = ET.Element(root_name)

    with open(csv_file, 'r', encoding='utf-8') as f:
        csv_reader = csv.DictReader(f)

        for row in csv_reader:
            record = ET.SubElement(root, record_name)

            for field, value in row.items():
                field_elem = ET.SubElement(record, field)
                field_elem.text = value

    tree = ET.ElementTree(root)
    ET.indent(tree, space='  ')  # Python 3.9+
    tree.write(xml_file, encoding='utf-8', xml_declaration=True)

# Usage
csv_to_xml('data.csv', 'output.xml')

# Output XML:
# <?xml version='1.0' encoding='utf-8'?>
# <data>
#   <record>
#     <name>John Doe</name>
#     <age>30</age>
#     <city>New York</city>
#   </record>
# </data>

// Using json2csv library
import { parse } from 'json2csv';

const data = [
  { name: 'John Doe', age: 30, city: 'New York' },
  { name: 'Jane Smith', age: 25, city: 'Los Angeles' }
];

const csv = parse(data);
console.log(csv);

// Custom options
const opts = {
  fields: ['name', 'age', 'city'],
  quote: '"',
  delimiter: ',',
  header: true
};

const csvCustom = parse(data, opts);

// Native JavaScript approach
function jsonToCsv(jsonData) {
  if (jsonData.length === 0) return '';

  const headers = Object.keys(jsonData[0]);
  const csvRows = [];

  // Add header row
  csvRows.push(headers.join(','));

  // Add data rows
  for (const row of jsonData) {
    const values = headers.map(header => {
      const value = row[header];
      // Escape quotes and wrap in quotes if needed
      if (typeof value === 'string' && (value.includes(',') || value.includes('"'))) {
        return '"' + value.replace(/"/g, '""') + '"';
      }
      return value;
    });
    csvRows.push(values.join(','));
  }

  return csvRows.join('\n');
}

const csvOutput = jsonToCsv(data);

import json
import csv
import pandas as pd

# Method 1: Using csv module
def json_to_csv(json_file, csv_file):
    with open(json_file, 'r') as f:
        data = json.load(f)

    if not data:
        return

    with open(csv_file, 'w', newline='', encoding='utf-8') as f:
        writer = csv.DictWriter(f, fieldnames=data[0].keys())
        writer.writeheader()
        writer.writerows(data)

# Method 2: Using pandas
df = pd.read_json('data.json')
df.to_csv('output.csv', index=False)

# From JSON string
json_string = '[{"name":"John","age":30}]'
df = pd.read_json(json_string)
df.to_csv('output.csv', index=False)

import pandas as pd
from pandas import json_normalize

# Nested JSON
json_data = [
    {
        'name': 'John',
        'age': 30,
        'address': {
            'city': 'New York',
            'zip': '10001'
        }
    }
]

# Flatten nested JSON
df = json_normalize(json_data)
df.to_csv('flattened.csv', index=False)

# Result columns: name, age, address.city, address.zip

# Custom flattening
def flatten_json(nested_json, prefix=''):
    flat = {}
    for key, value in nested_json.items():
        new_key = f"{prefix}{key}" if not prefix else f"{prefix}.{key}"
        if isinstance(value, dict):
            flat.update(flatten_json(value, new_key))
        else:
            flat[new_key] = value
    return flat

-- Export query results to CSV
SELECT *
INTO OUTFILE '/tmp/export.csv'
FIELDS TERMINATED BY ','
ENCLOSED BY '"'
LINES TERMINATED BY '\n'
FROM users
WHERE active = 1;

-- With headers (MySQL 8.0+)
SELECT 'id', 'name', 'email', 'created_at'
UNION ALL
SELECT id, name, email, created_at
FROM users
INTO OUTFILE '/tmp/users.csv'
FIELDS TERMINATED BY ','
ENCLOSED BY '"'
LINES TERMINATED BY '\n';

-- Export to CSV with headers
COPY (SELECT * FROM users WHERE active = true)
TO '/tmp/users.csv'
WITH (FORMAT CSV, HEADER true, DELIMITER ',');

-- Custom quote and escape characters
COPY users TO '/tmp/users.csv'
WITH (
    FORMAT CSV,
    HEADER true,
    DELIMITER ',',
    QUOTE '"',
    ESCAPE '\\'
);

-- Export from psql command line
\copy (SELECT * FROM users) TO 'users.csv' WITH CSV HEADER

import pandas as pd
from sqlalchemy import create_engine

# Create database connection
engine = create_engine('postgresql://user:pass@localhost/dbname')

# Query to DataFrame to CSV
query = "SELECT * FROM users WHERE active = true"
df = pd.read_sql(query, engine)
df.to_csv('users.csv', index=False)

# Alternative: using sqlite3
import sqlite3

conn = sqlite3.connect('database.db')
df = pd.read_sql_query("SELECT * FROM users", conn)
df.to_csv('users.csv', index=False)
conn.close()

const mysql = require('mysql2');
const { parse } = require('json2csv');
const fs = require('fs');

const connection = mysql.createConnection({
  host: 'localhost',
  user: 'root',
  password: 'password',
  database: 'mydb'
});

connection.query('SELECT * FROM users', (error, results) => {
  if (error) throw error;

  const csv = parse(results);
  fs.writeFileSync('users.csv', csv);

  connection.end();
});

// Using async/await
const util = require('util');
connection.query = util.promisify(connection.query);

async function exportToCSV() {
  const results = await connection.query('SELECT * FROM users');
  const csv = parse(results);
  fs.writeFileSync('users.csv', csv);
}

import pandas as pd

# Read Excel file
df = pd.read_excel('data.xlsx', sheet_name='Sheet1')

# Export to CSV
df.to_csv('output.csv', index=False, encoding='utf-8')

# Using openpyxl directly
from openpyxl import load_workbook
import csv

wb = load_workbook('data.xlsx')
ws = wb.active

with open('output.csv', 'w', newline='', encoding='utf-8') as f:
    writer = csv.writer(f)

    for row in ws.iter_rows(values_only=True):
        writer.writerow(row)

import pandas as pd

# Read all sheets
excel_file = pd.ExcelFile('data.xlsx')

# Export each sheet to separate CSV
for sheet_name in excel_file.sheet_names:
    df = pd.read_excel(excel_file, sheet_name=sheet_name)
    csv_filename = f'{sheet_name}.csv'
    df.to_csv(csv_filename, index=False)

# Combine all sheets into one CSV
all_sheets = []
for sheet_name in excel_file.sheet_names:
    df = pd.read_excel(excel_file, sheet_name=sheet_name)
    df['source_sheet'] = sheet_name  # Track origin
    all_sheets.append(df)

combined_df = pd.concat(all_sheets, ignore_index=True)
combined_df.to_csv('combined.csv', index=False)

const fs = require('fs');
const csv = require('csv-parser');

let processedCount = 0;

fs.createReadStream('large.csv')
  .pipe(csv())
  .on('data', (row) => {
    // Process each row
    if (row.age > 18) {
      // Do something with adult records
      processedCount++;
    }
  })
  .on('end', () => {
    console.log(`Processed ${processedCount} records`);
  })
  .on('error', (error) => {
    console.error('Error:', error);
  });

// Write CSV stream
const { stringify } = require('csv-stringify');
const writableStream = fs.createWriteStream('output.csv');

const stringifier = stringify({ header: true, columns: ['name', 'age'] });
stringifier.pipe(writableStream);

// Write rows
stringifier.write(['John Doe', 30]);
stringifier.write(['Jane Smith', 25]);
stringifier.end();

import csv

def process_large_csv(filename, chunk_size=1000):
    with open(filename, 'r', encoding='utf-8') as f:
        reader = csv.DictReader(f)
        chunk = []

        for row in reader:
            chunk.append(row)

            if len(chunk) >= chunk_size:
                # Process chunk
                process_chunk(chunk)
                chunk = []

        # Process remaining rows
        if chunk:
            process_chunk(chunk)

def process_chunk(rows):
    # Process rows in chunk
    for row in rows:
        # Do something with row
        pass

# Using pandas with iterator
import pandas as pd

for chunk in pd.read_csv('large.csv', chunksize=10000):
    # Process each chunk
    filtered = chunk[chunk['age'] > 18]
    # Save or process filtered data

import pandas as pd
import glob

# Merge multiple CSV files with same structure
csv_files = glob.glob('data_*.csv')

dfs = []
for file in csv_files:
    df = pd.read_csv(file)
    dfs.append(df)

merged_df = pd.concat(dfs, ignore_index=True)
merged_df.to_csv('merged.csv', index=False)

# Remove duplicates
merged_df.drop_duplicates(inplace=True)

# Merge with custom logic
def merge_csv_files(files):
    master_df = pd.read_csv(files[0])

    for file in files[1:]:
        df = pd.read_csv(file)
        master_df = pd.concat([master_df, df], ignore_index=True)

    return master_df

import pandas as pd

# Read CSV files
customers = pd.read_csv('customers.csv')
orders = pd.read_csv('orders.csv')

# Inner join
merged = pd.merge(customers, orders, on='customer_id', how='inner')

# Left join (all customers, even without orders)
merged = pd.merge(customers, orders, on='customer_id', how='left')

# Join on multiple columns
merged = pd.merge(
    customers,
    orders,
    left_on=['id', 'region'],
    right_on=['customer_id', 'region'],
    how='inner'
)

# Concatenate vertically (union)
combined = pd.concat([df1, df2], ignore_index=True)

# Save result
merged.to_csv('joined_data.csv', index=False)

import pandas as pd

df = pd.read_csv('data.csv')

# Column transformations
df['age_group'] = df['age'].apply(lambda x: 'Adult' if x >= 18 else 'Minor')
df['email_domain'] = df['email'].str.split('@').str[1]
df['name_upper'] = df['name'].str.upper()

# Conditional transformations
df['status'] = df['age'].apply(
    lambda x: 'Senior' if x >= 65 else 'Adult' if x >= 18 else 'Minor'
)

# Value mapping
df['gender'] = df['gender'].map({'M': 'Male', 'F': 'Female'})

# Filter rows
df_filtered = df[df['age'] > 18]

# Sort
df_sorted = df.sort_values(['age', 'name'], ascending=[False, True])

# Group and aggregate
summary = df.groupby('city').agg({
    'age': ['mean', 'min', 'max'],
    'name': 'count'
}).reset_index()

# Rename columns
df.rename(columns={'old_name': 'new_name'}, inplace=True)

# Drop columns
df.drop(['unwanted_column'], axis=1, inplace=True)

# Save transformed data
df.to_csv('transformed.csv', index=False)

sku,name,description,price,quantity,category,image_url
LAPTOP-001,"Gaming Laptop 15""","High-performance gaming laptop with RTX 4070",1299.99,50,Electronics,https://example.com/img1.jpg
MOUSE-001,Wireless Mouse,"Ergonomic wireless mouse with 6 buttons",29.99,200,Accessories,https://example.com/img2.jpg
KB-001,Mechanical Keyboard,"RGB mechanical keyboard, Cherry MX switches",89.99,75,Accessories,https://example.com/img3.jpg

date,transaction_id,customer_id,amount,category,payment_method,status
2024-12-01,TXN-001,CUST-1234,1299.99,Electronics,Credit Card,Completed
2024-12-01,TXN-002,CUST-5678,49.98,Books,PayPal,Completed
2024-12-02,TXN-003,CUST-9012,799.00,Electronics,Debit Card,Pending
2024-12-02,TXN-004,CUST-1234,25.00,Subscription,Credit Card,Completed

customer_id,first_name,last_name,email,phone,registration_date,status
1001,John,Doe,[email protected],+1-555-0101,2024-01-15,Active
1002,Jane,Smith,[email protected],+1-555-0102,2024-02-20,Active
1003,Bob,Johnson,[email protected],+1-555-0103,2024-03-10,Inactive