Enterprise Database Integration Guide

const fs = require('fs');
const readline = require('readline');
const { parse } = require('csv-parse');

class DomainCategorizer {
    constructor() {
        this.lookup = new Map();
    }

    async loadCSV(filePath) {
        return new Promise((resolve, reject) => {
            const parser = parse({
                columns: true,
                skip_empty_lines: true
            });

            fs.createReadStream(filePath)
                .pipe(parser)
                .on('data', (row) => {
                    const domain = row.Domain.toLowerCase().replace('www.', '');
                    this.lookup.set(domain, {
                        iabV2Tier1: row['IAB v2 Tier 1 Category'],
                        iabV2Tier2: row['IAB v2 Tier 2 Category'],
                        iabV2Tier3: row['IAB v2 Tier 3 Category'],
                        iabV2Tier4: row['IAB v2 Tier 4 Category'],
                        iabV3Tier1: row['IAB v3 Tier 1 Category'],
                        iabV3Tier2: row['IAB v3 Tier 2 Category'],
                        iabV3Tier3: row['IAB v3 Tier 3 Category'],
                        iabV3Tier4: row['IAB v3 Tier 4 Category'],
                        webFiltering: row['Web Filtering Category'],
                        personas: row['Personas'],
                        openPageRank: parseFloat(row['OpenPageRank']) || 0,
                        country: row['Country'],
                        simplified_category: row['Simplified Category']
                    });
                })
                .on('end', () => resolve())
                .on('error', reject);
        });
    }

    getCategory(domain) {
        const normalized = domain.toLowerCase().replace('www.', '');
        return this.lookup.get(normalized) || null;
    }

    getSimplifiedCategory(domain) {
        const result = this.getCategory(domain);
        return result ? result.simplified_category : null;
    }
}

// Usage
async function main() {
    const categorizer = new DomainCategorizer();
    await categorizer.loadCSV('enterprise_domains.csv');

    const result = categorizer.getCategory('google.com');
    console.log(`IAB v2: ${result.iabV2Tier1}`);
    console.log(`IAB v3: ${result.iabV3Tier1}`);
    console.log(`Simplified: ${result.simplified_category}`);
    console.log(`PageRank: ${result.openPageRank}`);
    console.log(`Country: ${result.country}`);

    // Batch lookup
    const domains = ['facebook.com', 'amazon.com', 'github.com'];
    domains.forEach(domain => {
        const cat = categorizer.getSimplifiedCategory(domain);
        console.log(`${domain}: ${cat}`);
    });
}

main().catch(console.error);

<?php

class DomainCategorizer {
    private array $lookup = [];

    public function __construct(string $csvPath) {
        $this->loadCSV($csvPath);
    }

    private function loadCSV(string $path): void {
        if (($handle = fopen($path, 'r')) !== false) {
            $headers = fgetcsv($handle);

            while (($row = fgetcsv($handle)) !== false) {
                if (count($row) === count($headers)) {
                    $data = array_combine($headers, $row);
                    $domain = strtolower(str_replace('www.', '', $data['Domain']));
                    $this->lookup[$domain] = $data;
                }
            }
            fclose($handle);
        }
    }

    public function getCategory(string $domain): ?array {
        $normalized = strtolower(str_replace('www.', '', $domain));
        return $this->lookup[$normalized] ?? null;
    }

    public function getSimplifiedCategory(string $domain): ?string {
        $result = $this->getCategory($domain);
        return $result['Simplified Category'] ?? null;
    }

    // Memory-efficient streaming for large files
    public static function processInChunks(string $path, callable $callback): void {
        if (($handle = fopen($path, 'r')) !== false) {
            $headers = fgetcsv($handle);

            while (($row = fgetcsv($handle)) !== false) {
                if (count($row) === count($headers)) {
                    $data = array_combine($headers, $row);
                    $callback($data);
                }
            }
            fclose($handle);
        }
    }
}

// Usage
$categorizer = new DomainCategorizer('enterprise_domains.csv');

$result = $categorizer->getCategory('google.com');
echo "Category: " . $result['Simplified Category'] . "\n";

// Streaming large files
DomainCategorizer::processInChunks('enterprise_domains.csv', function($row) {
    echo $row['Domain'] . ': ' . $row['Simplified Category'] . "\n";
});

import java.io.*;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

public class DomainCategorizer {
    private Map<String, DomainData> lookup = new ConcurrentHashMap<>();

    public static class DomainData {
        public String iabTier1, iabTier2, iabTier3, iabTier4;
        public String webFiltering, simplifiedCategory;
    }

    public void loadCSV(String filePath) throws IOException {
        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
            String headerLine = reader.readLine();
            String[] headers = headerLine.split(",");

            String line;
            while ((line = reader.readLine()) != null) {
                String[] values = parseCSVLine(line);
                if (values.length >= 7) {
                    DomainData data = new DomainData();
                    data.iabTier1 = values[1];
                    data.iabTier2 = values[2];
                    data.iabTier3 = values[3];
                    data.iabTier4 = values[4];
                    data.webFiltering = values[5];
                    data.simplifiedCategory = values[6];

                    String domain = values[0].toLowerCase().replace("www.", "");
                    lookup.put(domain, data);
                }
            }
        }
    }

    public DomainData getCategory(String domain) {
        String normalized = domain.toLowerCase().replace("www.", "");
        return lookup.get(normalized);
    }

    public String getSimplifiedCategory(String domain) {
        DomainData result = getCategory(domain);
        return result != null ? result.simplifiedCategory : null;
    }

    private String[] parseCSVLine(String line) {
        // Handle quoted CSV fields
        List<String> result = new ArrayList<>();
        StringBuilder current = new StringBuilder();
        boolean inQuotes = false;

        for (char c : line.toCharArray()) {
            if (c == '"') {
                inQuotes = !inQuotes;
            } else if (c == ',' && !inQuotes) {
                result.add(current.toString().trim());
                current = new StringBuilder();
            } else {
                current.append(c);
            }
        }
        result.add(current.toString().trim());
        return result.toArray(new String[0]);
    }

    public static void main(String[] args) throws IOException {
        DomainCategorizer categorizer = new DomainCategorizer();
        categorizer.loadCSV("enterprise_domains.csv");

        DomainData result = categorizer.getCategory("google.com");
        System.out.println("Category: " + result.simplifiedCategory);
    }
}

using System;
using System.Collections.Generic;
using System.IO;
using Microsoft.VisualBasic.FileIO;

public class DomainCategorizer
{
    private Dictionary<string, DomainData> _lookup = new();

    public class DomainData
    {
        public string IabTier1 { get; set; }
        public string IabTier2 { get; set; }
        public string IabTier3 { get; set; }
        public string IabTier4 { get; set; }
        public string WebFiltering { get; set; }
        public string SimplifiedCategory { get; set; }
    }

    public void LoadCSV(string filePath)
    {
        using var parser = new TextFieldParser(filePath);
        parser.TextFieldType = FieldType.Delimited;
        parser.SetDelimiters(",");
        parser.HasFieldsEnclosedInQuotes = true;

        // Skip header
        string[] headers = parser.ReadFields();

        while (!parser.EndOfData)
        {
            string[] fields = parser.ReadFields();
            if (fields.Length >= 7)
            {
                var data = new DomainData
                {
                    IabTier1 = fields[1],
                    IabTier2 = fields[2],
                    IabTier3 = fields[3],
                    IabTier4 = fields[4],
                    WebFiltering = fields[5],
                    SimplifiedCategory = fields[6]
                };

                string domain = fields[0].ToLower().Replace("www.", "");
                _lookup[domain] = data;
            }
        }
    }

    public DomainData GetCategory(string domain)
    {
        string normalized = domain.ToLower().Replace("www.", "");
        return _lookup.TryGetValue(normalized, out var data) ? data : null;
    }

    public string GetSimplifiedCategory(string domain)
    {
        var result = GetCategory(domain);
        return result?.SimplifiedCategory;
    }
}

// Usage
class Program
{
    static void Main()
    {
        var categorizer = new DomainCategorizer();
        categorizer.LoadCSV("enterprise_domains.csv");

        var result = categorizer.GetCategory("google.com");
        Console.WriteLine($"Category: {result?.SimplifiedCategory}");
    }
}

package main

import (
    "encoding/csv"
    "fmt"
    "os"
    "strings"
    "sync"
)

type DomainData struct {
    IABTier1           string
    IABTier2           string
    IABTier3           string
    IABTier4           string
    WebFiltering       string
    SimplifiedCategory string
}

type DomainCategorizer struct {
    lookup map[string]DomainData
    mu     sync.RWMutex
}

func NewDomainCategorizer() *DomainCategorizer {
    return &DomainCategorizer{
        lookup: make(map[string]DomainData),
    }
}

func (dc *DomainCategorizer) LoadCSV(filePath string) error {
    file, err := os.Open(filePath)
    if err != nil {
        return err
    }
    defer file.Close()

    reader := csv.NewReader(file)

    // Skip header
    _, err = reader.Read()
    if err != nil {
        return err
    }

    for {
        record, err := reader.Read()
        if err != nil {
            break
        }

        if len(record) >= 7 {
            domain := strings.ToLower(strings.Replace(record[0], "www.", "", 1))
            dc.lookup[domain] = DomainData{
                IABTier1:           record[1],
                IABTier2:           record[2],
                IABTier3:           record[3],
                IABTier4:           record[4],
                WebFiltering:       record[5],
                SimplifiedCategory: record[6],
            }
        }
    }
    return nil
}

func (dc *DomainCategorizer) GetCategory(domain string) (DomainData, bool) {
    dc.mu.RLock()
    defer dc.mu.RUnlock()

    normalized := strings.ToLower(strings.Replace(domain, "www.", "", 1))
    data, exists := dc.lookup[normalized]
    return data, exists
}

func (dc *DomainCategorizer) GetSimplifiedCategory(domain string) string {
    if data, exists := dc.GetCategory(domain); exists {
        return data.SimplifiedCategory
    }
    return ""
}

func main() {
    categorizer := NewDomainCategorizer()
    err := categorizer.LoadCSV("enterprise_domains.csv")
    if err != nil {
        panic(err)
    }

    if data, exists := categorizer.GetCategory("google.com"); exists {
        fmt.Printf("Category: %s\n", data.SimplifiedCategory)
    }
}

require 'csv'

class DomainCategorizer
  def initialize(csv_path)
    @lookup = {}
    load_csv(csv_path)
  end

  def load_csv(path)
    CSV.foreach(path, headers: true) do |row|
      domain = row['Domain'].downcase.gsub('www.', '')
      @lookup[domain] = {
        iab_tier1: row['IAB v3 Tier 1 Category'],
        iab_tier2: row['IAB v3 Tier 2 Category'],
        iab_tier3: row['IAB v3 Tier 3 Category'],
        iab_tier4: row['IAB v3 Tier 4 Category'],
        web_filtering: row['Web Filtering Category'],
        simplified_category: row['Simplified Category']
      }
    end
  end

  def get_category(domain)
    normalized = domain.downcase.gsub('www.', '')
    @lookup[normalized]
  end

  def get_simplified_category(domain)
    result = get_category(domain)
    result&.dig(:simplified_category)
  end

  # Memory-efficient streaming
  def self.process_in_chunks(path, &block)
    CSV.foreach(path, headers: true) do |row|
      yield row.to_h
    end
  end
end

# Usage
categorizer = DomainCategorizer.new('enterprise_domains.csv')

result = categorizer.get_category('google.com')
puts "Category: #{result[:simplified_category]}"

# Streaming
DomainCategorizer.process_in_chunks('enterprise_domains.csv') do |row|
  puts "#{row['Domain']}: #{row['Simplified Category']}"
end

const fs = require('fs');
const readline = require('readline');

class DomainCategorizerJSON {
    constructor() {
        this.lookup = new Map();
    }

    async loadJSON(filePath) {
        const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
        data.forEach(item => {
            this.lookup.set(item.domain.toLowerCase(), item);
        });
    }

    getCategory(domain) {
        const normalized = domain.toLowerCase().replace('www.', '');
        return this.lookup.get(normalized) || null;
    }

    // Stream NDJSON (newline-delimited JSON)
    async *streamNDJSON(filePath) {
        const rl = readline.createInterface({
            input: fs.createReadStream(filePath),
            crlfDelay: Infinity
        });

        for await (const line of rl) {
            if (line.trim()) {
                yield JSON.parse(line);
            }
        }
    }
}

// Usage
async function main() {
    const categorizer = new DomainCategorizerJSON();
    await categorizer.loadJSON('enterprise_domains.json');

    const result = categorizer.getCategory('google.com');
    console.log(`Category: ${result.simplified_category}`);

    // Stream processing
    for await (const domain of categorizer.streamNDJSON('domains.ndjson')) {
        console.log(`${domain.domain}: ${domain.simplified_category}`);
    }
}

main();

<?php

class DomainCategorizerJSON {
    private array $lookup = [];

    public function __construct(string $jsonPath) {
        $data = json_decode(file_get_contents($jsonPath), true);
        foreach ($data as $item) {
            $domain = strtolower($item['domain']);
            $this->lookup[$domain] = $item;
        }
    }

    public function getCategory(string $domain): ?array {
        $normalized = strtolower(str_replace('www.', '', $domain));
        return $this->lookup[$normalized] ?? null;
    }

    // Stream large JSON files
    public static function streamJSON(string $path, callable $callback): void {
        $handle = fopen($path, 'r');
        $buffer = '';
        $inObject = false;
        $depth = 0;

        while (!feof($handle)) {
            $char = fgetc($handle);

            if ($char === '{') {
                $inObject = true;
                $depth++;
            }

            if ($inObject) {
                $buffer .= $char;

                if ($char === '}') {
                    $depth--;
                    if ($depth === 0) {
                        $item = json_decode($buffer, true);
                        if ($item) $callback($item);
                        $buffer = '';
                        $inObject = false;
                    }
                }
            }
        }
        fclose($handle);
    }
}

// Usage
$categorizer = new DomainCategorizerJSON('enterprise_domains.json');
$result = $categorizer->getCategory('google.com');
echo "Category: " . $result['simplified_category'] . "\n";

# Pretty print and filter with jq
cat enterprise_domains.json | jq '.[] | select(.simplified_category == "Technology")'

# Extract specific fields (all categories)
cat enterprise_domains.json | jq -r '.[] | "\(.domain),\(.iab_v2_tier1),\(.iab_v3_tier1),\(.simplified_category)"'

# Filter by country and PageRank
cat enterprise_domains.json | jq '.[] | select(.country == "United States" and .open_page_rank > 7)'

# Convert to NDJSON for streaming
cat enterprise_domains.json | jq -c '.[]' > domains.ndjson

# Count domains per Simplified category
cat enterprise_domains.json | jq -r '.[].simplified_category' | sort | uniq -c | sort -rn

# Count domains per country
cat enterprise_domains.json | jq -r '.[].country' | sort | uniq -c | sort -rn