आप के पास एक 500MB CSV फ़ाइल है और पूछना चाहते हैं एक्सेल में सह-पाइलोट यह कर सकता है, लेकिन क्या यदि आपका डेटा क्लाऊड सेवाओं के लिए बहुत संवेदनशील है

यह अनुच्छेद आपको दिखाता है कि कैसे C में - स्थानीय रूप से, निजी रूप से

सीएसवी फ़ाइलों को सीधे क्वेरी करने के लिए DuckDB का उपयोग करें

एक अनुपूरक के लिए , अधिक CLI- फोकस उपचार जो LLM इंटरफेस के रूप में सांख्यिकी प्रोफाइलों का उपयोग करने पर विस्तार करता है और इन विचारों को लागू करने की पूरी उपकरण दिखाता है। डेटासममारीजर: त्वरित स्थानीय डाटा प्रोफ़ाइलिंग विशेष रूप से अनुभाग "Key Upgrade

कोर इंस्टीट्यूट

डेटा भंडार के रूप में LLM का उपयोग गलत आकलन है।

सही पैटर्न LLM कारण

flowchart LR
    A[User Question] --> B[LLM]
    B --> C[SQL Query]
    C --> D[DuckDB]
    D --> E[Results]
    
    style B stroke:#333,stroke-width:4px
    style D stroke:#333,stroke-width:4px

क्या हो रहा है ध्यान दें? LLM आपके प्रश्न और स्कीमा पर आधारित एक एसक्यूएल क्वेरी उत्पन्न करता है.

LLM अंतरफलक के रूप में प्रोफाइलों का व्यवहार करने पर अधिक जानकारी के लिए (और एक ठोस सीएलआई जो प्रोफ़ाइल को लागू करता है। डेटासममारीजर: त्वरित स्थानीय डाटा प्रोफ़ाइलिंग.

इसे सिर्फ मेमोरी में लोड क्यों नहीं करें

स्पष्ट दृष्टिकोणों में सभी एक ही घातक दोष है

सीएसवीHelperComment डाटाफ्रेम: संपूर्ण फ़ाइल को RAM में लोड करें

SQLite / PostgreSQL: एक धीमी आयात चरण की आवश्यकता होती है

**पांडसAI**अभी भी सब कुछ स्मृति में लोड करता है

क्यों डकडीबी

डक डीबी भिन्न है. यह सीएसवी फ़ाइलों की पूछताछ करता है सीधा आयात चरण नहीं है

using var connection = new DuckDBConnection("DataSource=:memory:");
connection.Open();
using var cmd = connection.CreateCommand();
cmd.CommandText = "SELECT Region, SUM(Amount) FROM 'sales.csv' GROUP BY Region";
// Executes directly against the file - no import, no memory explosion

घातक विशेषता यह फ़ाइलों को तालिका के रूप में व्यवहार करता है. इसे सीएसवी पर चिह्नित करें।

डकडीबी है क्या डेटा इंजिनियर्स पाइथोन में इस उपयोग के लिए उपयोग करते हैं .NET बाइंडिंग आप को पूरा ADO देता है

स्टैक

घटक |-----------|--------------| | डक डीबी क्वेरी सीएसवी सीधे | डकडीबी पूर्ण ADO | ओलामाCity name (optional, probably does not need a translation) | स्थानीय अनुमान | बोगस किसी भी पैमाने पर वास्तविक परीक्षण डेटा | qwen2.5-coder:7b सबसे अच्छा SQL सटीकता 7B आकार में

सुरक्षा पर नोटहम LLM को निष्पादित कर रहे हैं सुरक्षा खंड सुरक्षा के लिए. प्रोफाइलों को एलएलएम इंटरफेस में बदलने और इन पैटर्नों को लागू करने वाले सीएलआई के बारे में विस्तृत चर्चा के लिए डेटासममारीजर: त्वरित स्थानीय डाटा प्रोफ़ाइलिंग.

परियोजना सेटअप

एक नमूना परियोजना बनाएँ

dotnet add package DuckDB.NET.Data.Full
dotnet add package OllamaSharp
dotnet add package Bogus

एक कोडन खींचना

ollama pull qwen2.5-coder:7b

वास्तुकला

यहाँ यह है कि कैसे टुकड़े एक साथ मिलते हैं

flowchart TB
    subgraph Input
        Q[User Question]
        CSV[CSV File]
    end
    
    subgraph Processing
        Schema[Extract Schema]
        Sample[Get Sample Rows]
        Context[Build LLM Context]
        LLM[Generate SQL]
        Validate[Validate SQL]
        Execute[Execute Query]
    end
    
    subgraph Output
        Results[Query Results]
    end
    
    CSV --> Schema
    CSV --> Sample
    Schema --> Context
    Sample --> Context
    Q --> Context
    Context --> LLM
    LLM --> Validate
    Validate -->|Error| LLM
    Validate -->|OK| Execute
    CSV --> Execute
    Execute --> Results
    
    style LLM stroke:#333,stroke-width:4px
    style Execute stroke:#333,stroke-width:4px

प्रमुख अंतर्दृष्टि-: हम LLM दे रहे हैं स्कीमा और नमूना डेटावास्तविक डेटा नहीं है

यह क्यों महत्वपूर्ण हैLLM उद्देश्य उत्पन्न करता है. डेटासममारीजर: त्वरित स्थानीय डाटा प्रोफ़ाइलिंग.

चरण 1: बोग्स के साथ परीक्षण डाटा उत्पन्न करें

पहले से ही सीएसवी डाटा है में जाएँ चरण 2: योजना संदर्भ बनाएँ.

हमारे LLM का परीक्षण करने से पहले हमें विश्लेषण के लिए डेटा की जरूरत है।

1. मापन परीक्षण निष्पादन को विभिन्न आकारों पर सत्यापित करने के लिए - उत्पन्न करें
2. गोपनीयता - वास्तविक ग्राहक को प्रदर्शित करने की कोई जोखिम नहीं
3. प्रजननक्षमता Same seed = same data, making bugs reproducible
4. किनारा केस वितरण को नियंत्रित करें

बोगस क्या है

बोगस एक लोकप्रिय फेकर का नेट पोर्ट है। दृष्य वास्तविक:

• f.Name.FullName() →
• f.Internet.Email() @item: inlistbox Sort By
• f.Date.Between(start, end) → वास्तविक तिथि वितरण
• f.Commerce.ProductName() → "Handcrafted Granite Cheese

यह महत्वपूर्ण है क्योंकि वास्तविक डेटा आपको समस्याओं को पता लगाने में मदद करता है

डाटा मॉडल परिभाषित करें

internal class SaleRecord
{
    public string OrderId { get; set; } = "";
    public DateTime OrderDate { get; set; }
    public string CustomerId { get; set; } = "";
    public string CustomerName { get; set; } = "";
    public string Region { get; set; } = "";
    public string Category { get; set; } = "";
    public string ProductName { get; set; } = "";
    public int Quantity { get; set; }
    public decimal UnitPrice { get; set; }
    public decimal Discount { get; set; }
    public bool IsReturned { get; set; }
}

फेकर कॉन्फ़िगर करें

निर्माण नियमों को परिभाषित करने के लिए बोगस एक प्रवाहित API का उपयोग करता है

var categories = new[] { "Electronics", "Clothing", "Home & Garden", "Sports", "Books" };
var regions = new[] { "North", "South", "East", "West", "Central" };

var faker = new Faker<SaleRecord>()
    .RuleFor(s => s.OrderId, f => f.Random.Guid().ToString()[..8].ToUpper())
    .RuleFor(s => s.OrderDate, f => f.Date.Between(
        new DateTime(2022, 1, 1), 
        new DateTime(2024, 12, 31)))
    .RuleFor(s => s.CustomerId, f => $"CUST-{f.Random.Number(10000, 99999)}")
    .RuleFor(s => s.CustomerName, f => f.Name.FullName())
    .RuleFor(s => s.Region, f => f.PickRandom(regions))
    .RuleFor(s => s.Category, f => f.PickRandom(categories))
    .RuleFor(s => s.ProductName, (f, s) => GenerateProductName(f, s.Category))
    .RuleFor(s => s.Quantity, f => f.Random.Number(1, 20))
    .RuleFor(s => s.UnitPrice, f => f.Random.Decimal(9.99m, 299.99m))
    .RuleFor(s => s.Discount, f => f.Random.Bool(0.3f) ? f.Random.Decimal(0.05m, 0.25m) : 0m)
    .RuleFor(s => s.IsReturned, f => f.Random.Bool(0.05f));

क्या हो रहा है

• f ( सभी डेटा मॉड्यूलों तक पहुँच के साथ जेनेरेटर इंस्टैंस
• f.Random.Guid().ToString()[..8] - एक GUID उत्पन्न करें लेकिन एक पठनीय क्रम आईडी के लिए केवल पहले 8 अक्षर ले लो
• f.Date.Between() वास्तविक दायरे के भीतर अनियमित तिथि
• f.PickRandom(array) पूर्वपरिभाषित विकल्पों से अनियमित रूप में चुनें
• f.Random.Bool(0.3f) सच्चे होने की संभावना
• (f, s) वाक्य-रचना - दोनों फेकर और आंशिक रूप से अभिगम करता है ProductName पर निर्भर Category

(f, s) पैटर्न शक्तिशाली है - इसका मतलब यह है कि "इलेक्ट्रॉनिक्स" क्रमादेश इलेक्ट्रॉनिक उत्पाद नाम प्राप्त करते हैं

सीएसवी में उत्पन्न करें और लिखें

var records = faker.Generate(100_000); // Adjust for your testing needs

await using var writer = new StreamWriter(csvPath, false, Encoding.UTF8);
await writer.WriteLineAsync("OrderId,OrderDate,CustomerId,CustomerName,Region,Category,...");

foreach (var record in records)
{
    var total = record.Quantity * record.UnitPrice * (1 - record.Discount);
    await writer.WriteLineAsync($"{record.OrderId},{record.OrderDate:yyyy-MM-dd},...");
}

पंक्तियां लगभग 15MB CSV को उत्पन्न करती हैं।

टिप: सेट Randomizer.Seed = new Random(12345) प्रतिपादनीय डेटा प्राप्त करने के लिए उत्पन्न करने से पहले

चरण 2: योजना संदर्भ बनाएँ

LLM SQL उत्पन्न करने से पहले यह डेटा संरचना को समझने की जरूरत है

संदर्भ मॉडल

public class DataContext
{
    public string CsvPath { get; set; } = "";
    public List<ColumnInfo> Columns { get; set; } = new();
    public List<Dictionary<string, string>> SampleRows { get; set; } = new();
    public long RowCount { get; set; }
}

public class ColumnInfo
{
    public string Name { get; set; } = "";
    public string Type { get; set; } = "";  // VARCHAR, DOUBLE, TIMESTAMP, etc.
}

यह सभी LLM की जरूरत है captures

स्कीमा निकाल रहा है

डकडीबी सभी लोड किए बिना किसी भी सीएसवी का वर्णन कर सकता है

private DataContext BuildContext(DuckDBConnection connection, string csvPath)
{
    var context = new DataContext { CsvPath = csvPath };

    // Get schema - DuckDB infers types from the CSV
    using var cmd = connection.CreateCommand();
    cmd.CommandText = $"DESCRIBE SELECT * FROM '{csvPath}'";
    using var reader = cmd.ExecuteReader();

    while (reader.Read())
    {
        context.Columns.Add(new ColumnInfo
        {
            Name = reader.GetString(0),  // Column name
            Type = reader.GetString(1)   // Inferred type
        });
    }

    return context;
}

DESCRIBE कमांड सिर्फ फ़ाइल हेडर और कुछ पंक्तियों के लिए प्रकार अनुमान पढ़ता है.

नमूना डाटा प्राप्त कर रहा है

नमूना पंक्ति LLM को डेटा प्रारूपों को समझने में मदद करती है

using var cmd = connection.CreateCommand();
cmd.CommandText = $"SELECT * FROM '{csvPath}' LIMIT 3";
using var reader = cmd.ExecuteReader();

while (reader.Read())
{
    var row = new Dictionary<string, string>();
    for (int i = 0; i < reader.FieldCount; i++)
    {
        var value = reader.IsDBNull(i) ? "NULL" : reader.GetValue(i)?.ToString() ?? "";
        row[reader.GetName(i)] = value;
    }
    context.SampleRows.Add(row);
}

तीन पंक्तियां सामान्यतः पर्याप्त है - यह LLM को दिखाता है कि टोकन बर्बाद किए बिना क्या प्रारूपों की आशा करें

चरण 3: LLM के साथ SQL उत्पन्न करें

यह कठिन हिस्सा है यहाँ त्वरित अभियांत्रिकी गैर है।

द प्रोम्प्ट निर्माण

private string BuildPrompt(DataContext context, string question, string? previousError)
{
    var sb = new StringBuilder();

    sb.AppendLine("You are a SQL expert. Generate a DuckDB SQL query to answer the user's question.");
    sb.AppendLine();
    sb.AppendLine("IMPORTANT RULES:");
    sb.AppendLine("1. The table is accessed directly from the CSV file path");
    sb.AppendLine("2. Use single quotes around the file path in FROM clause");
    sb.AppendLine("3. DuckDB syntax - use LIMIT not TOP, use || for string concat");
    sb.AppendLine("4. Return ONLY the SQL query, no explanation, no markdown");
    sb.AppendLine();
    
    sb.AppendLine($"CSV File: '{context.CsvPath}'");
    sb.AppendLine($"Row Count: {context.RowCount:N0}");
    sb.AppendLine();
    
    // Schema
    sb.AppendLine("Schema:");
    foreach (var col in context.Columns)
    {
        sb.AppendLine($"  - {col.Name}: {col.Type}");
    }

नियम अनुभाग महत्वपूर्ण है - यह LLM को यह बताता है कि exactly how to format the query for DuckDB

नमूना डाटा जोड़ें

    if (context.SampleRows.Count > 0)
    {
        sb.AppendLine();
        sb.AppendLine("Sample data (first 3 rows):");
        foreach (var row in context.SampleRows)
        {
            var values = row.Select(kv => $"{kv.Key}='{kv.Value}'");
            sb.AppendLine($"  {{{string.Join(", ", values)}}}");
        }
    }

त्रुटि पुनर्प्राप्ति

यदि पिछला प्रयास असफल रहा है, तो त्रुटि शामिल करें

    if (previousError != null)
    {
        sb.AppendLine();
        sb.AppendLine("YOUR PREVIOUS QUERY HAD AN ERROR:");
        sb.AppendLine(previousError);
        sb.AppendLine("Please fix the query based on this error.");
    }

    sb.AppendLine();
    sb.AppendLine($"Question: {question}");
    sb.AppendLine();
    sb.AppendLine("SQL Query (no markdown, no explanation):");

    return sb.ToString();
}

यह पुनः प्रयास प्रक्रिया महत्वपूर्ण है - स्थानीय LLM कभी-कभी वाक्य संरचना त्रुटियाँ करते हैं

एलएलएम को बुला रहा है

var request = new GenerateRequest { Model = _model, Prompt = prompt };
var response = await _ollama.GenerateAsync(request).StreamToEndAsync();
var sql = CleanSqlResponse(response?.Response ?? "");

StreamToEndAsync() पूरा जवाब की प्रतीक्षा करता है. बेहतर UX के लिए, तुम टोकन को जब वे आ जाते हैं, स्ट्रीम कर सकते थे

प्रतिक्रिया को साफ करना

LLMs अक्सर मार्कडाउन कोड ब्लॉकों में एसक्यूएल को लपेटते हैं हालांकि उन्हें यह नहीं कहा गया है

private string CleanSqlResponse(string response)
{
    var sql = response.Trim();

    // Remove markdown code blocks if present
    if (sql.StartsWith("```"))
    {
        var lines = sql.Split('\n').ToList();
        lines.RemoveAt(0);  // Remove opening ```sql
        if (lines.Count > 0 && lines[^1].Trim().StartsWith("```"))
        {
            lines.RemoveAt(lines.Count - 1);  // Remove closing ```
        }
        sql = string.Join('\n', lines);
    }

    return sql.Trim('`', ' ', '\n', '\r');
}

चरण 4: निष्पादन से पहले वैध करें

डकडीबी EXPLAIN हमें क्वेरी चलाने के बिना एसक्यूएल वाक्य संरचना जाँच करने देता है

private string? ValidateSql(DuckDBConnection connection, string sql)
{
    try
    {
        using var cmd = connection.CreateCommand();
        cmd.CommandText = $"EXPLAIN {sql}";
        cmd.ExecuteNonQuery();
        return null; // Valid
    }
    catch (Exception ex)
    {
        return ex.Message;
    }
}

यदि सत्यापन असफल होता है तो हम LLM में त्रुटि को फिर से भेजते हैं और एक सीमा तक पुनः प्रयास करें

चरण 5: निष्पादन और प्रारूप परिणाम

अंत में क्वेरी चलाएँ और आउटपुट को प्रारूपित करें

private QueryResult ExecuteQuery(DuckDBConnection connection, string sql)
{
    var result = new QueryResult { Sql = sql };

    try
    {
        using var cmd = connection.CreateCommand();
        cmd.CommandText = sql;
        using var reader = cmd.ExecuteReader();

        // Capture column names
        for (int i = 0; i < reader.FieldCount; i++)
        {
            result.Columns.Add(reader.GetName(i));
        }

        // Capture rows
        while (reader.Read())
        {
            var row = new List<object?>();
            for (int i = 0; i < reader.FieldCount; i++)
            {
                row.Add(reader.IsDBNull(i) ? null : reader.GetValue(i));
            }
            result.Rows.Add(row);
        }

        result.Success = true;
    }
    catch (Exception ex)
    {
        result.Success = false;
        result.Error = ex.Message;
    }

    return result;
}

QueryResult वर्ग ( नमूना परियोजना में पूर्ण रूप से दिखाया गया है ToString() विधि जो परिणाम को एक पठनीय तालिका के रूप में प्रारूपित करता है

वार्तालाप संदर्भ जोड़ें

अंतःक्रियात्मक विश्लेषण के लिए उपयोगकर्ता अक्सर निम्नलिखित सवाल पूछना चाहते हैं

"What's the total revenue?"
→ "Break that down by region"
→ "Show the top 5 regions"

दूसरा और तीसरा प्रश्न केवल पहले से संदर्भ के साथ अर्थ रखता है

वार्तालाप इतिहास ट्रैक कर रहा है

public class ConversationTurn
{
    public string Question { get; set; } = "";
    public string Sql { get; set; } = "";
    public bool Success { get; set; }
    public int RowCount { get; set; }
    public string Summary { get; set; } = "";  // "Single value: 1234567.89"
}

प्रोम्प्ट में इतिहास सम्मिलित करें

if (_history.Count > 0)
{
    sb.AppendLine();
    sb.AppendLine("CONVERSATION HISTORY (for context):");
    
    foreach (var turn in _history.TakeLast(5))  // Last 5 turns
    {
        sb.AppendLine($"Q: {turn.Question}");
        sb.AppendLine($"SQL: {turn.Sql}");
        if (turn.Success)
        {
            sb.AppendLine($"Result: {turn.Summary}");
        }
        sb.AppendLine();
    }
}

इतिहास LLM संदर्भ को इस तरह के संदर्भों को समझने के लिए प्रदान करता है जैसे "that",

किस मॉडल का उपयोग करना है

एसक्यूएल जनन के लिए, कोडिंग- फोकस मॉडल सबसे अच्छा काम करते हैं Ollama's मॉडल लाइब्रेरी:

अधिकतर प्रयोग के लिए qwen2.5-coder:7b सॉफ्ट स्पॉट करता है - सटीक SQL

निष्पादन

Real-विश्व मानदंड

एक मानक डेव मशीन पर 100K पंक्ति CSV फ़ाइल पर परीक्षण

क्वेरी प्रकार |------------|------| साधारण गणना SUM के साथ | GROUP BY फ़िल्टर के साथ जटिल समूहन | बहु - तालिका समूह के साथ HAVING

पर विश्लेषणात्मक क्वेरी के लिए उप--100ms | | K पंक्तियों | - | किसी भी आयात चरण के बिना |. | क्वेरि जटिलता पंक्ति गणना से अधिक महत्वपूर्ण है

बड़े फ़ाइलों को पार्केट में बदलें

से अधिक फ़ाइलों के लिए पार्केट प्रारूप है 10-100x तेजी से

using var cmd = connection.CreateCommand();
cmd.CommandText = $"COPY (SELECT * FROM '{csvPath}') TO '{parquetPath}' (FORMAT PARQUET)";
cmd.ExecuteNonQuery();

संकुचित पार्केट फ़ाइल भी बहुत छोटा है.

सुरक्षा संबंधी विचार

निष्पादित करने के दौरान LLM

private bool IsSafeQuery(string sql)
{
    var dangerous = new[] { "DROP", "DELETE", "TRUNCATE", "UPDATE", "INSERT", "ALTER", "CREATE" };
    var upperSql = sql.ToUpperInvariant();
    return !dangerous.Any(d => upperSql.Contains(d));
}

डक डीबी में ' मेमोरी मोड भी प्राकृतिक अलगाव प्रदान करता है. यह आपके उत्पादन डेटाबेस को प्रभावित नहीं कर सकता

पूर्ण उदाहरण

यहाँ यह सब कैसे एक साथ आता है

// Generate test data
await GenerateSalesCsvAsync("sales.csv", 100_000);

// Simple query
using var service = new CsvQueryService("qwen2.5-coder:7b", verbose: true);
var result = await service.QueryAsync("sales.csv", "What are total sales by region?");
Console.WriteLine(result);

// Conversational analysis
using var analyser = new ConversationalCsvAnalyser("sales.csv", "qwen2.5-coder:7b");

Console.WriteLine(await analyser.AskAsync("What's the total revenue?"));
Console.WriteLine(await analyser.AskAsync("Break that down by category"));
Console.WriteLine(await analyser.AskAsync("Which category has the most returns?"));

सारांश

बनाए रखने के लिए मानसिक मॉडल LLMs कारण

LLM को डेटा फ़ीड नहीं करें।

क्रियान्वयन

1. डक डीबी सीएसवी सीधी से प्रश्न करता है - कोई आयात नहीं करता है
2. योजना + नमूने LLM को बिना डेटा के पर्याप्त संदर्भ दें
3. कठोर प्रवर्धन नियम बल निर्धारणात्मक SQL, रचनात्मक गद्य नहीं
4. स्पष्टीकरण के माध्यम से वैधता निष्पादन से पहले त्रुटि पकड़ता है
5. त्रुटि प्रतिक्रिया के साथ पुनः प्रयास करें कभी-कभी वाक्य संरचना स्लिप को संभालता है

परिणाम million पर विश्लेषणात्मक क्वेरी | - | पंक्ति फ़ाइल |, | पूरी तरह ऑफ़लाइन |

पूरा नमूना परियोजना इस पर उपलब्ध है सबसे अधिक स्पष्ट - में शामिल है CsvQueryService, ConversationalCsvAnalyser, और बोगस

संसाधन

डक डीबी

• डकडीबी दस्तावेज़ीकरण - पूर्ण संदर्भ
• डकडीबी सीएसवी आयात विशेष विशेषताएँ
• डकडीबी एसक्यूएल संदर्भ - अन्य डेटाबेसों से एसक्यूएल वाक्य संरचना अंतर
• डकडीबी - CM SK1 बंधन
• डकडीबी - मूल द्विआधारी के साथ पूरा पैकेज

Ollama & LLMs

• ओलामाCity name (optional, probably does not need a translation) - स्थानीय LLM रनटाइम
• ओललामा मॉडल लाइब्रेरी उपलब्ध मॉडल
• ओल्लामाशर्प क्लाइंट लाइब्रेरी
• ओललामाशर्प नुगेट

डाटा बनाने का परीक्षण करें

• बोगस जिटहब - मिथ्या डेटा जनरेटर
• बोगस API संदर्भ - उपलब्ध डेटा प्रकार

वैकल्पिक उल्लेखित

• सीएसवीHelperComment - सीएसवी विश्लेषण लाइब्रेरी
• माइक्रोसॉफ्ट के लिए - डेटाफ्रेम
• पांडसAI - पाइथोन LLM

संबंधित लेख

• डेटासममारीजर: त्वरित स्थानीय डाटा प्रोफ़ाइलिंग - CLI के आधार पर डेटा प्रोफाइलिंग को शामिल करने वाला अनुषंगी अनुच्छेद