From c86c8237c01f306edbc5fad41dc397ddd47c9012 Mon Sep 17 00:00:00 2001
From: tangwang <tangwang@essa.top>
Date: Tue, 11 Nov 2025 20:46:04 +0800
Subject: [PATCH] 支持聚合。过滤项补充了逻辑，但是有问题

---
 api/models.py                             |   4 ++++
 api/routes/search.py                      |   5 ++++-
 config/schema/customer1_config.yaml       |  15 +++++++++++++++
 debug_sort_query.py                       |  89 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 frontend/index.html                       |  24 +++++++++++++++++++-----
 frontend/static/css/style.css             | 150 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 frontend/static/js/app.js                 | 292 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-------
 search/es_query_builder.py                |  90 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
 search/multilang_query_builder.py         |  65 +++++++++++++++++++++++++++++++++++++++++++++++------------------
 search/searcher.py                        |  23 ++++++++++++++++++++---
 simple_server.py                          | 340 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 test_aggregation_api.py                   | 166 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 test_aggregation_functionality.py         | 236 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 test_complete_search.py                   | 211 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 test_minimal_sort.py                      |  45 +++++++++++++++++++++++++++++++++++++++++++++
 tests/integration/test_aggregation_api.py | 256 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 16 files changed, 1976 insertions(+), 35 deletions(-)
 create mode 100644 debug_sort_query.py
 create mode 100644 simple_server.py
 create mode 100644 test_aggregation_api.py
 create mode 100644 test_aggregation_functionality.py
 create mode 100644 test_complete_search.py
 create mode 100644 test_minimal_sort.py
 create mode 100644 tests/integration/test_aggregation_api.py

diff --git a/api/models.py b/api/models.py
index cfdfadc..be1dffa 100644
--- a/api/models.py
+++ b/api/models.py
@@ -13,6 +13,10 @@ class SearchRequest(BaseModel):
     from_: int = Field(0, ge=0, alias="from", description="Offset for pagination")
     filters: Optional[Dict[str, Any]] = Field(None, description="Additional filters")
     min_score: Optional[float] = Field(None, description="Minimum score threshold")
+    # 新增字段
+    aggregations: Optional[Dict[str, Any]] = Field(None, description="Aggregation specifications")
+    sort_by: Optional[str] = Field(None, description="Sort field name")
+    sort_order: Optional[str] = Field("desc", description="Sort order: 'asc' or 'desc'")
 
 
 class ImageSearchRequest(BaseModel):
diff --git a/api/routes/search.py b/api/routes/search.py
index 63b260f..6ded0aa 100644
--- a/api/routes/search.py
+++ b/api/routes/search.py
@@ -68,7 +68,10 @@ async def search(request: SearchRequest, http_request: Request):
             from_=request.from_,
             filters=request.filters,
             min_score=request.min_score,
-            context=context
+            context=context,
+            aggregations=request.aggregations,
+            sort_by=request.sort_by,
+            sort_order=request.sort_order
         )
 
         # Include performance summary in response
diff --git a/config/schema/customer1_config.yaml b/config/schema/customer1_config.yaml
index 84e9ba1..27cd35c 100644
--- a/config/schema/customer1_config.yaml
+++ b/config/schema/customer1_config.yaml
@@ -115,6 +115,21 @@ fields:
     index: true
     store: false
 
+  - name: "supplierName_keyword"
+    type: "KEYWORD"
+    source_table: "extension"
+    source_column: "supplierName"
+    index: true
+    store: false
+
+  # Price Fields
+  - name: "price"
+    type: "DOUBLE"
+    source_table: "extension"
+    source_column: "price"
+    index: true
+    store: true
+
   # Text Embedding Fields
   - name: "name_embedding"
     type: "TEXT_EMBEDDING"
diff --git a/debug_sort_query.py b/debug_sort_query.py
new file mode 100644
index 0000000..d9bf3f0
--- /dev/null
+++ b/debug_sort_query.py
@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""
+Debug script to check the generated ES query for sorting
+"""
+
+import requests
+import json
+
+def test_simple_sort():
+    """Test simple sort functionality via API"""
+
+    print("Testing simple sort via API...")
+
+    # Test without sort first
+    request_no_sort = {
+        "query": "芭比",
+        "size": 1
+    }
+
+    print("\n1. Search without sort:")
+    try:
+        response = requests.post("http://120.76.41.98:6002/search/", json=request_no_sort)
+        print(f"Status: {response.status_code}")
+        if response.ok:
+            data = response.json()
+            print(f"Results: {data.get('total', 0)} found in {data.get('took_ms', 0)}ms")
+        else:
+            print(f"Error: {response.text}")
+    except Exception as e:
+        print(f"Exception: {e}")
+
+    # Test with sort
+    request_with_sort = {
+        "query": "芭比",
+        "size": 1,
+        "sort_by": "create_time",
+        "sort_order": "desc"
+    }
+
+    print("\n2. Search with sort:")
+    print(f"Request: {json.dumps(request_with_sort, ensure_ascii=False, indent=2)}")
+
+    try:
+        response = requests.post("http://120.76.41.98:6002/search/", json=request_with_sort)
+        print(f"Status: {response.status_code}")
+        if response.ok:
+            data = response.json()
+            print(f"Results: {data.get('total', 0)} found in {data.get('took_ms', 0)}ms")
+
+            if 'hits' in data and data['hits']:
+                hit = data['hits'][0]
+                source = hit.get('_source', {})
+                print(f"Sample result: {source.get('name', 'N/A')}")
+                print(f"Create time: {source.get('create_time', 'N/A')}")
+        else:
+            print(f"Error: {response.text}")
+    except Exception as e:
+        print(f"Exception: {e}")
+
+    # Test with different sort field
+    request_price_sort = {
+        "query": "芭比",
+        "size": 1,
+        "sort_by": "price",
+        "sort_order": "asc"
+    }
+
+    print("\n3. Search with price sort:")
+    print(f"Request: {json.dumps(request_price_sort, ensure_ascii=False, indent=2)}")
+
+    try:
+        response = requests.post("http://120.76.41.98:6002/search/", json=request_price_sort)
+        print(f"Status: {response.status_code}")
+        if response.ok:
+            data = response.json()
+            print(f"Results: {data.get('total', 0)} found in {data.get('took_ms', 0)}ms")
+
+            if 'hits' in data and data['hits']:
+                hit = data['hits'][0]
+                source = hit.get('_source', {})
+                print(f"Sample result: {source.get('name', 'N/A')}")
+                print(f"Price: {source.get('price', 'N/A')}")
+        else:
+            print(f"Error: {response.text}")
+    except Exception as e:
+        print(f"Exception: {e}")
+
+if __name__ == "__main__":
+    test_simple_sort()
\ No newline at end of file
diff --git a/frontend/index.html b/frontend/index.html
index 6023808..19b34dd 100644
--- a/frontend/index.html
+++ b/frontend/index.html
@@ -21,14 +21,18 @@
             </div>
 
             <div class="search-options">
-                <label><input type="checkbox" id="enableTranslation" checked> 启用翻译</label>
-                <label><input type="checkbox" id="enableEmbedding" checked> 启用语义搜索</label>
-                <label><input type="checkbox" id="enableRerank" checked> 启用自定义排序</label>
                 <select id="resultSize">
                     <option value="10">10条结果</option>
                     <option value="20">20条结果</option>
                     <option value="50">50条结果</option>
                 </select>
+                <select id="sortBy">
+                    <option value="">默认排序</option>
+                    <option value="create_time:desc">上架时间（新到旧）</option>
+                    <option value="create_time:asc">上架时间（旧到新）</option>
+                    <option value="price:asc">价格（低到高）</option>
+                    <option value="price:desc">价格（高到低）</option>
+                </select>
             </div>
 
             <div class="search-examples">
@@ -45,9 +49,19 @@
             <p>搜索中...</p>
         </div>
 
-        <div id="results" class="results-section"></div>
+        <div class="content-wrapper">
+            <div id="aggregationPanel" class="aggregation-panel" style="display: none;">
+                <h3>筛选条件</h3>
+                <div id="activeFilters" class="active-filters"></div>
+                <div id="aggregationResults" class="aggregation-results"></div>
+            </div>
+
+            <div class="main-content">
+                <div id="results" class="results-section"></div>
 
-        <div id="queryInfo" class="query-info"></div>
+                <div id="queryInfo" class="query-info"></div>
+            </div>
+        </div>
     </div>
 
     <footer>
diff --git a/frontend/static/css/style.css b/frontend/static/css/style.css
index d3abda7..cab68ce 100644
--- a/frontend/static/css/style.css
+++ b/frontend/static/css/style.css
@@ -280,3 +280,153 @@ footer {
     font-size: 24px;
     margin-bottom: 10px;
 }
+
+/* Layout for aggregation and main content */
+.content-wrapper {
+    display: flex;
+    gap: 20px;
+    align-items: flex-start;
+}
+
+/* Aggregation Panel */
+.aggregation-panel {
+    background: white;
+    border-radius: 15px;
+    padding: 20px;
+    box-shadow: 0 10px 30px rgba(0,0,0,0.1);
+    width: 300px;
+    flex-shrink: 0;
+}
+
+.aggregation-panel h3 {
+    color: #333;
+    margin-bottom: 20px;
+    font-size: 1.3em;
+    border-bottom: 2px solid #667eea;
+    padding-bottom: 10px;
+}
+
+/* Active Filters */
+.active-filters-list {
+    margin-bottom: 20px;
+    display: flex;
+    flex-wrap: wrap;
+    gap: 8px;
+    align-items: center;
+}
+
+.active-filter-tag {
+    background: #667eea;
+    color: white;
+    padding: 4px 8px;
+    border-radius: 15px;
+    font-size: 12px;
+    display: flex;
+    align-items: center;
+    gap: 5px;
+}
+
+.remove-filter {
+    background: none;
+    border: none;
+    color: white;
+    cursor: pointer;
+    font-size: 14px;
+    font-weight: bold;
+    padding: 0;
+    width: 16px;
+    height: 16px;
+    border-radius: 50%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.remove-filter:hover {
+    background: rgba(255,255,255,0.2);
+}
+
+.clear-filters {
+    background: #ff4444;
+    color: white;
+    border: none;
+    padding: 4px 12px;
+    border-radius: 15px;
+    font-size: 12px;
+    cursor: pointer;
+    transition: background 0.3s;
+}
+
+.clear-filters:hover {
+    background: #cc0000;
+}
+
+/* Aggregation Groups */
+.aggregation-group {
+    margin-bottom: 25px;
+}
+
+.aggregation-group h4 {
+    color: #555;
+    margin-bottom: 10px;
+    font-size: 1.1em;
+    font-weight: 600;
+}
+
+.aggregation-items {
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+}
+
+.aggregation-item {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    cursor: pointer;
+    padding: 5px;
+    border-radius: 5px;
+    transition: background-color 0.2s;
+}
+
+.aggregation-item:hover {
+    background-color: #f5f5f5;
+}
+
+.aggregation-item input[type="checkbox"] {
+    margin: 0;
+}
+
+.aggregation-item span {
+    flex: 1;
+    font-size: 14px;
+    color: #333;
+}
+
+.aggregation-item .count {
+    color: #888;
+    font-size: 12px;
+    font-weight: normal;
+}
+
+/* Main content area */
+.main-content {
+    flex: 1;
+    min-width: 0; /* Allow content to shrink */
+}
+
+/* Responsive design */
+@media (max-width: 768px) {
+    .content-wrapper {
+        flex-direction: column;
+    }
+
+    .aggregation-panel {
+        width: 100%;
+        order: 2; /* Show below results on mobile */
+    }
+
+    .main-content {
+        order: 1;
+    }
+}
diff --git a/frontend/static/js/app.js b/frontend/static/js/app.js
index bec5553..d76fd35 100644
--- a/frontend/static/js/app.js
+++ b/frontend/static/js/app.js
@@ -19,6 +19,9 @@ function setQuery(query) {
     performSearch();
 }
 
+// 全局变量存储当前的过滤条件
+let currentFilters = {};
+
 // Perform search
 async function performSearch() {
     const query = document.getElementById('searchInput').value.trim();
@@ -28,16 +31,57 @@ async function performSearch() {
         return;
     }
 
-    // Get options (temporarily disable translation and embedding due to GPU issues)
+    // Get options
     const size = parseInt(document.getElementById('resultSize').value);
-    const enableTranslation = false; // Disabled temporarily
-    const enableEmbedding = false;  // Disabled temporarily
-    const enableRerank = document.getElementById('enableRerank').checked;
+    const sortByValue = document.getElementById('sortBy').value;
+
+    // Parse sort option
+    let sort_by = null;
+    let sort_order = 'desc';
+    if (sortByValue) {
+        const [field, order] = sortByValue.split(':');
+        sort_by = field;
+        sort_order = order;
+    }
+
+    // Define aggregations for faceted search
+    const aggregations = {
+        "category_stats": {
+            "terms": {
+                "field": "categoryName_keyword",
+                "size": 10
+            }
+        },
+        "brand_stats": {
+            "terms": {
+                "field": "brandName_keyword",
+                "size": 10
+            }
+        },
+        "supplier_stats": {
+            "terms": {
+                "field": "supplierName_keyword",
+                "size": 10
+            }
+        },
+        "price_ranges": {
+            "range": {
+                "field": "price",
+                "ranges": [
+                    {"key": "0-50", "to": 50},
+                    {"key": "50-100", "from": 50, "to": 100},
+                    {"key": "100-200", "from": 100, "to": 200},
+                    {"key": "200+", "from": 200}
+                ]
+            }
+        }
+    };
 
     // Show loading
     document.getElementById('loading').style.display = 'block';
     document.getElementById('results').innerHTML = '';
     document.getElementById('queryInfo').innerHTML = '';
+    document.getElementById('aggregationResults').innerHTML = '';
 
     try {
         const response = await fetch(`${API_BASE_URL}/search/`, {
@@ -48,9 +92,10 @@ async function performSearch() {
             body: JSON.stringify({
                 query: query,
                 size: size,
-                enable_translation: enableTranslation,
-                enable_embedding: enableEmbedding,
-                enable_rerank: enableRerank
+                filters: Object.keys(currentFilters).length > 0 ? currentFilters : null,
+                aggregations: aggregations,
+                sort_by: sort_by,
+                sort_order: sort_order
             })
         });
 
@@ -61,6 +106,8 @@ async function performSearch() {
         const data = await response.json();
         displayResults(data);
         displayQueryInfo(data.query_info);
+        displayAggregations(data.aggregations);
+        displayActiveFilters();
 
     } catch (error) {
         console.error('Search error:', error);
@@ -119,6 +166,7 @@ function displayResults(data) {
                 </div>
 
                 <div class="result-meta">
+                    ${source.price ? `<span>💰 ¥${escapeHtml(source.price)}</span>` : ''}
                     ${source.categoryName ? `<span>📁 ${escapeHtml(source.categoryName)}</span>` : ''}
                     ${source.brandName ? `<span>🏷️ ${escapeHtml(source.brandName)}</span>` : ''}
                     ${source.supplierName ? `<span>🏭 ${escapeHtml(source.supplierName)}</span>` : ''}
@@ -227,6 +275,236 @@ function getLanguageName(code) {
     return names[code] || code;
 }
 
+// Display aggregations
+function displayAggregations(aggregations) {
+    if (!aggregations || Object.keys(aggregations).length === 0) {
+        document.getElementById('aggregationPanel').style.display = 'none';
+        return;
+    }
+
+    document.getElementById('aggregationPanel').style.display = 'block';
+    const aggregationResultsDiv = document.getElementById('aggregationResults');
+
+    let html = '';
+
+    // Category aggregation
+    if (aggregations.category_stats && aggregations.category_stats.buckets) {
+        html += `
+            <div class="aggregation-group">
+                <h4>商品分类</h4>
+                <div class="aggregation-items">
+        `;
+
+        aggregations.category_stats.buckets.forEach(bucket => {
+            const key = bucket.key;
+            const count = bucket.doc_count;
+            const isChecked = currentFilters.categoryName_keyword && currentFilters.categoryName_keyword.includes(key);
+
+            html += `
+                <label class="aggregation-item">
+                    <input type="checkbox"
+                           ${isChecked ? 'checked' : ''}
+                           onchange="toggleFilter('categoryName_keyword', '${escapeHtml(key)}', this.checked)">
+                    <span>${escapeHtml(key)}</span>
+                    <span class="count">(${count})</span>
+                </label>
+            `;
+        });
+
+        html += '</div></div>';
+    }
+
+    // Brand aggregation
+    if (aggregations.brand_stats && aggregations.brand_stats.buckets) {
+        html += `
+            <div class="aggregation-group">
+                <h4>品牌</h4>
+                <div class="aggregation-items">
+        `;
+
+        aggregations.brand_stats.buckets.forEach(bucket => {
+            const key = bucket.key;
+            const count = bucket.doc_count;
+            const isChecked = currentFilters.brandName_keyword && currentFilters.brandName_keyword.includes(key);
+
+            html += `
+                <label class="aggregation-item">
+                    <input type="checkbox"
+                           ${isChecked ? 'checked' : ''}
+                           onchange="toggleFilter('brandName_keyword', '${escapeHtml(key)}', this.checked)">
+                    <span>${escapeHtml(key)}</span>
+                    <span class="count">(${count})</span>
+                </label>
+            `;
+        });
+
+        html += '</div></div>';
+    }
+
+    // Supplier aggregation
+    if (aggregations.supplier_stats && aggregations.supplier_stats.buckets) {
+        html += `
+            <div class="aggregation-group">
+                <h4>供应商</h4>
+                <div class="aggregation-items">
+        `;
+
+        aggregations.supplier_stats.buckets.slice(0, 5).forEach(bucket => {
+            const key = bucket.key;
+            const count = bucket.doc_count;
+            const isChecked = currentFilters.supplierName_keyword && currentFilters.supplierName_keyword.includes(key);
+
+            html += `
+                <label class="aggregation-item">
+                    <input type="checkbox"
+                           ${isChecked ? 'checked' : ''}
+                           onchange="toggleFilter('supplierName_keyword', '${escapeHtml(key)}', this.checked)">
+                    <span>${escapeHtml(key)}</span>
+                    <span class="count">(${count})</span>
+                </label>
+            `;
+        });
+
+        html += '</div></div>';
+    }
+
+    // Price range aggregation
+    if (aggregations.price_ranges && aggregations.price_ranges.buckets) {
+        html += `
+            <div class="aggregation-group">
+                <h4>价格区间</h4>
+                <div class="aggregation-items">
+        `;
+
+        aggregations.price_ranges.buckets.forEach(bucket => {
+            const key = bucket.key;
+            const count = bucket.doc_count;
+            const isChecked = currentFilters.price_ranges && currentFilters.price_ranges.includes(key);
+
+            const priceLabel = {
+                '0-50': '¥0-50',
+                '50-100': '¥50-100',
+                '100-200': '¥100-200',
+                '200+': '¥200+'
+            };
+
+            html += `
+                <label class="aggregation-item">
+                    <input type="checkbox"
+                           ${isChecked ? 'checked' : ''}
+                           onchange="togglePriceFilter('${escapeHtml(key)}', this.checked)">
+                    <span>${priceLabel[key] || key}</span>
+                    <span class="count">(${count})</span>
+                </label>
+            `;
+        });
+
+        html += '</div></div>';
+    }
+
+    aggregationResultsDiv.innerHTML = html;
+}
+
+// Display active filters
+function displayActiveFilters() {
+    const activeFiltersDiv = document.getElementById('activeFilters');
+
+    if (Object.keys(currentFilters).length === 0) {
+        activeFiltersDiv.innerHTML = '';
+        return;
+    }
+
+    let html = '<div class="active-filters-list">';
+
+    Object.entries(currentFilters).forEach(([field, values]) => {
+        if (Array.isArray(values)) {
+            values.forEach(value => {
+                let displayValue = value;
+                if (field === 'price_ranges') {
+                    const priceLabel = {
+                        '0-50': '¥0-50',
+                        '50-100': '¥50-100',
+                        '100-200': '¥100-200',
+                        '200+': '¥200+'
+                    };
+                    displayValue = priceLabel[value] || value;
+                }
+
+                html += `
+                    <span class="active-filter-tag">
+                        ${escapeHtml(displayValue)}
+                        <button onclick="removeFilter('${field}', '${escapeHtml(value)}')" class="remove-filter">×</button>
+                    </span>
+                `;
+            });
+        }
+    });
+
+    html += `<button onclick="clearAllFilters()" class="clear-filters">清除所有</button></div>`;
+    activeFiltersDiv.innerHTML = html;
+}
+
+// Toggle filter
+function toggleFilter(field, value, checked) {
+    if (checked) {
+        if (!currentFilters[field]) {
+            currentFilters[field] = [];
+        }
+        if (!currentFilters[field].includes(value)) {
+            currentFilters[field].push(value);
+        }
+    } else {
+        if (currentFilters[field]) {
+            const index = currentFilters[field].indexOf(value);
+            if (index > -1) {
+                currentFilters[field].splice(index, 1);
+            }
+            if (currentFilters[field].length === 0) {
+                delete currentFilters[field];
+            }
+        }
+    }
+
+    // Re-run search with new filters
+    performSearch();
+}
+
+// Toggle price filter
+function togglePriceFilter(value, checked) {
+    if (checked) {
+        if (!currentFilters.price_ranges) {
+            currentFilters.price_ranges = [];
+        }
+        if (!currentFilters.price_ranges.includes(value)) {
+            currentFilters.price_ranges.push(value);
+        }
+    } else {
+        if (currentFilters.price_ranges) {
+            const index = currentFilters.price_ranges.indexOf(value);
+            if (index > -1) {
+                currentFilters.price_ranges.splice(index, 1);
+            }
+            if (currentFilters.price_ranges.length === 0) {
+                delete currentFilters.price_ranges;
+            }
+        }
+    }
+
+    // Re-run search with new filters
+    performSearch();
+}
+
+// Remove single filter
+function removeFilter(field, value) {
+    toggleFilter(field, value, false);
+}
+
+// Clear all filters
+function clearAllFilters() {
+    currentFilters = {};
+    performSearch();
+}
+
 // Initialize page
 document.addEventListener('DOMContentLoaded', function() {
     console.log('SearchEngine Frontend loaded');
diff --git a/search/es_query_builder.py b/search/es_query_builder.py
index 7cb8cf3..1e2aa5a 100644
--- a/search/es_query_builder.py
+++ b/search/es_query_builder.py
@@ -202,7 +202,36 @@ class ESQueryBuilder:
         filter_clauses = []
 
         for field, value in filters.items():
-            if isinstance(value, dict):
+            if field == 'price_ranges':
+                # Handle price range filters
+                if isinstance(value, list):
+                    price_ranges = []
+                    for price_range in value:
+                        if price_range == '0-50':
+                            price_ranges.append({"lt": 50})
+                        elif price_range == '50-100':
+                            price_ranges.append({"gte": 50, "lt": 100})
+                        elif price_range == '100-200':
+                            price_ranges.append({"gte": 100, "lt": 200})
+                        elif price_range == '200+':
+                            price_ranges.append({"gte": 200})
+
+                    if price_ranges:
+                        if len(price_ranges) == 1:
+                            filter_clauses.append({
+                                "range": {
+                                    "price": price_ranges[0]
+                                }
+                            })
+                        else:
+                            # Multiple price ranges - use bool should clause
+                            range_clauses = [{"range": {"price": pr}} for pr in price_ranges]
+                            filter_clauses.append({
+                                "bool": {
+                                    "should": range_clauses
+                                }
+                            })
+            elif isinstance(value, dict):
                 # Range query
                 if "gte" in value or "lte" in value or "gt" in value or "lt" in value:
                     filter_clauses.append({
@@ -266,6 +295,65 @@ class ESQueryBuilder:
 
         return es_query
 
+    def add_dynamic_aggregations(
+        self,
+        es_query: Dict[str, Any],
+        aggregations: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Add dynamic aggregations based on request parameters.
+
+        Args:
+            es_query: Existing ES query
+            aggregations: Aggregation specifications
+
+        Returns:
+            Modified ES query
+        """
+        if "aggs" not in es_query:
+            es_query["aggs"] = {}
+
+        for agg_name, agg_spec in aggregations.items():
+            es_query["aggs"][agg_name] = agg_spec
+
+        return es_query
+
+    def add_sorting(
+        self,
+        es_query: Dict[str, Any],
+        sort_by: str,
+        sort_order: str = "desc"
+    ) -> Dict[str, Any]:
+        """
+        Add sorting to ES query.
+
+        Args:
+            es_query: Existing ES query
+            sort_by: Field name for sorting
+            sort_order: Sort order: 'asc' or 'desc'
+
+        Returns:
+            Modified ES query
+        """
+        if not sort_by:
+            return es_query
+
+        if not sort_order:
+            sort_order = "desc"
+
+        if "sort" not in es_query:
+            es_query["sort"] = []
+
+        # Add the specified sort
+        sort_field = {
+            sort_by: {
+                "order": sort_order.lower()
+            }
+        }
+        es_query["sort"].append(sort_field)
+
+        return es_query
+
     def add_aggregations(
         self,
         es_query: Dict[str, Any],
diff --git a/search/multilang_query_builder.py b/search/multilang_query_builder.py
index 773202a..06946e5 100644
--- a/search/multilang_query_builder.py
+++ b/search/multilang_query_builder.py
@@ -319,7 +319,11 @@ class MultiLanguageQueryBuilder(ESQueryBuilder):
         if hasattr(node, 'operator'):
             # QueryNode object
             operator = node.operator
-            terms = node.terms
+            terms = node.terms if hasattr(node, 'terms') else None
+
+            # For TERM nodes, check if there's a value
+            if operator == 'TERM' and hasattr(node, 'value') and node.value:
+                terms = node.value
         elif isinstance(node, tuple) and len(node) > 0:
             # Tuple format from boolean parser
             if hasattr(node[0], 'operator'):
@@ -353,9 +357,7 @@ class MultiLanguageQueryBuilder(ESQueryBuilder):
         else:
             return {"match_all": {}}
 
-        print(f"[MultiLangQueryBuilder] Building boolean query for operator: {operator}")
-        print(f"[MultiLangQueryBuilder] Terms: {terms}")
-
+        
         if operator == 'TERM':
             # Leaf node - handle field:query format
             if isinstance(terms, str) and ':' in terms:
@@ -365,31 +367,58 @@ class MultiLanguageQueryBuilder(ESQueryBuilder):
                         field: value
                     }
                 }
+            elif isinstance(terms, str):
+                # Simple text term - create match query
+                return {
+                    "multi_match": {
+                        "query": terms,
+                        "fields": self.match_fields,
+                        "type": "best_fields",
+                        "operator": "AND"
+                    }
+                }
             else:
-                return {"match_all": {}}
+                # Invalid TERM node - return empty match
+                return {
+                    "match_none": {}
+                }
 
         elif operator == 'OR':
             # Any term must match
             should_clauses = []
-            for term in terms:
-                should_clauses.append(self._build_boolean_query_from_tuple(term))
-            return {
-                "bool": {
-                    "should": should_clauses,
-                    "minimum_should_match": 1
+            if terms:
+                for term in terms:
+                    clause = self._build_boolean_query_from_tuple(term)
+                    if clause and clause.get("match_none") is None:
+                        should_clauses.append(clause)
+
+            if should_clauses:
+                return {
+                    "bool": {
+                        "should": should_clauses,
+                        "minimum_should_match": 1
+                    }
                 }
-            }
+            else:
+                return {"match_none": {}}
 
         elif operator == 'AND':
             # All terms must match
             must_clauses = []
-            for term in terms:
-                must_clauses.append(self._build_boolean_query_from_tuple(term))
-            return {
-                "bool": {
-                    "must": must_clauses
+            if terms:
+                for term in terms:
+                    clause = self._build_boolean_query_from_tuple(term)
+                    if clause and clause.get("match_none") is None:
+                        must_clauses.append(clause)
+
+            if must_clauses:
+                return {
+                    "bool": {
+                        "must": must_clauses
+                    }
                 }
-            }
+            else:
+                return {"match_none": {}}
 
         elif operator == 'ANDNOT':
             # First term must match, second must not
diff --git a/search/searcher.py b/search/searcher.py
index ee0dd7c..cb69ae2 100644
--- a/search/searcher.py
+++ b/search/searcher.py
@@ -103,7 +103,10 @@ class Searcher:
         from_: int = 0,
         filters: Optional[Dict[str, Any]] = None,
         min_score: Optional[float] = None,
-        context: Optional[RequestContext] = None
+        context: Optional[RequestContext] = None,
+        aggregations: Optional[Dict[str, Any]] = None,
+        sort_by: Optional[str] = None,
+        sort_order: Optional[str] = "desc"
     ) -> SearchResult:
         """
         Execute search query.
@@ -115,6 +118,9 @@ class Searcher:
             filters: Additional filters (field: value pairs)
             min_score: Minimum score threshold
             context: Request context for tracking (created if not provided)
+            aggregations: Aggregation specifications for faceted search
+            sort_by: Field name for sorting
+            sort_order: Sort order: 'asc' or 'desc'
 
         Returns:
             SearchResult object
@@ -146,7 +152,10 @@ class Searcher:
             'enable_translation': enable_translation,
             'enable_embedding': enable_embedding,
             'enable_rerank': enable_rerank,
-            'min_score': min_score
+            'min_score': min_score,
+            'aggregations': aggregations,
+            'sort_by': sort_by,
+            'sort_order': sort_order
         }
 
         context.metadata['feature_flags'] = {
@@ -247,11 +256,19 @@ class Searcher:
                 )
 
             # Add aggregations for faceted search
-            if filters:
+            if aggregations:
+                # Use dynamic aggregations from request
+                es_query = self.query_builder.add_dynamic_aggregations(es_query, aggregations)
+            elif filters:
+                # Fallback to filter-based aggregations
                 agg_fields = [f"{k}_keyword" for k in filters.keys() if f"{k}_keyword" in [f.name for f in self.config.fields]]
                 if agg_fields:
                     es_query = self.query_builder.add_aggregations(es_query, agg_fields)
 
+            # Add sorting if specified
+            if sort_by:
+                es_query = self.query_builder.add_sorting(es_query, sort_by, sort_order)
+
             # Extract size and from from body for ES client parameters
             body_for_es = {k: v for k, v in es_query.items() if k not in ['size', 'from']}
 
diff --git a/simple_server.py b/simple_server.py
new file mode 100644
index 0000000..25fda66
--- /dev/null
+++ b/simple_server.py
@@ -0,0 +1,340 @@
+#!/usr/bin/env python3
+"""
+Simple API server for testing aggregation functionality without external dependencies.
+"""
+
+import json
+import time
+import random
+from http.server import HTTPServer, BaseHTTPRequestHandler
+from urllib.parse import urlparse, parse_qs
+import threading
+
+class SearchAPIHandler(BaseHTTPRequestHandler):
+    """Simple API handler for search requests."""
+
+    def do_OPTIONS(self):
+        """Handle CORS preflight requests."""
+        self.send_response(200)
+        self.send_header('Access-Control-Allow-Origin', '*')
+        self.send_header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
+        self.send_header('Access-Control-Allow-Headers', 'Content-Type')
+        self.end_headers()
+
+    def do_POST(self):
+        """Handle POST requests."""
+        if self.path == '/':
+            self.handle_search()
+        elif self.path == '/search/':
+            self.handle_search()
+        else:
+            self.send_response(404)
+            self.end_headers()
+
+    def handle_search(self):
+        """Handle search requests with aggregations."""
+        try:
+            # Read request body
+            content_length = int(self.headers['Content-Length'])
+            post_data = self.rfile.read(content_length)
+            request_data = json.loads(post_data.decode('utf-8'))
+
+            query = request_data.get('query', '')
+            size = request_data.get('size', 10)
+            sort_by = request_data.get('sort_by', 'relevance')
+            aggregations = request_data.get('aggregations', {})
+            filters = request_data.get('filters', {})
+
+            print(f"Search request: query='{query}', size={size}, sort_by={sort_by}")
+            print(f"Aggregations: {list(aggregations.keys()) if aggregations else 'None'}")
+            print(f"Filters: {filters if filters else 'None'}")
+
+            # Simulate processing time
+            time.sleep(0.1)
+
+            # Generate mock search results
+            results = self.generate_mock_results(query, size, sort_by, filters)
+
+            # Generate mock aggregations
+            aggregation_results = self.generate_mock_aggregations(aggregations, filters)
+
+            # Build response
+            response = {
+                "hits": results,
+                "total": len(results) + random.randint(10, 100),
+                "max_score": round(random.uniform(1.5, 3.5), 3),
+                "took_ms": random.randint(15, 45),
+                "aggregations": aggregation_results,
+                "query_info": {
+                    "original_query": query,
+                    "rewritten_query": query,
+                    "detected_language": "zh" if any('\u4e00' <= char <= '\u9fff' for char in query) else "en",
+                    "domain": "default",
+                    "translations": {},
+                    "has_vector": False
+                }
+            }
+
+            # Send response
+            self.send_response(200)
+            self.send_header('Content-Type', 'application/json')
+            self.send_header('Access-Control-Allow-Origin', '*')
+            self.end_headers()
+
+            response_json = json.dumps(response, ensure_ascii=False, indent=2)
+            self.wfile.write(response_json.encode('utf-8'))
+
+            print(f"Response sent with {len(results)} results and {len(aggregation_results)} aggregations")
+
+        except Exception as e:
+            print(f"Error handling request: {e}")
+            self.send_response(500)
+            self.send_header('Content-Type', 'application/json')
+            self.send_header('Access-Control-Allow-Origin', '*')
+            self.end_headers()
+
+            error_response = {
+                "error": str(e),
+                "detail": "Internal server error"
+            }
+
+            self.wfile.write(json.dumps(error_response).encode('utf-8'))
+
+    def generate_mock_results(self, query, size, sort_by, filters):
+        """Generate mock search results."""
+
+        # Sample product data
+        sample_products = [
+            {
+                "skuId": 1001,
+                "name": "芭比娃娃梦幻套装",
+                "enSpuName": "Barbie Dream House Playset",
+                "ruSkuName": "Кукла Барби Мечтательный домик",
+                "categoryName": "芭比",
+                "brandName": "美泰",
+                "supplierName": "义乌玩具厂",
+                "price": 89.99,
+                "imageUrl": "https://picsum.photos/seed/barbie1/200/200.jpg",
+                "create_time": "2024-01-15T10:30:00Z",
+                "days_since_last_update": 45
+            },
+            {
+                "skuId": 1002,
+                "name": "芭比娃娃时尚系列",
+                "enSpuName": "Barbie Fashion Doll Collection",
+                "ruSkuName": "Кукла Барби Модная коллекция",
+                "categoryName": "芭比",
+                "brandName": "美泰",
+                "supplierName": "汕头玩具公司",
+                "price": 45.50,
+                "imageUrl": "https://picsum.photos/seed/barbie2/200/200.jpg",
+                "create_time": "2024-02-20T14:15:00Z",
+                "days_since_last_update": 30
+            },
+            {
+                "skuId": 1003,
+                "name": "儿童积木套装",
+                "enSpuName": "Kids Building Blocks Set",
+                "ruSkuName": "Детский строительный набор",
+                "categoryName": "积木",
+                "brandName": "乐高",
+                "supplierName": "深圳塑胶制品厂",
+                "price": 158.00,
+                "imageUrl": "https://picsum.photos/seed/blocks1/200/200.jpg",
+                "create_time": "2024-01-10T09:20:00Z",
+                "days_since_last_update": 60
+            },
+            {
+                "skuId": 1004,
+                "name": "消防车玩具模型",
+                "enSpuName": "Fire Truck Toy Model",
+                "ruSkuName": "Модель пожарной машины",
+                "categoryName": "小汽车",
+                "brandName": "多美卡",
+                "supplierName": "东莞玩具制造厂",
+                "price": 78.50,
+                "imageUrl": "https://picsum.photos/seed/firetruck1/200/200.jpg",
+                "create_time": "2024-03-05T16:45:00Z",
+                "days_since_last_update": 15
+            },
+            {
+                "skuId": 1005,
+                "name": "婴儿毛绒玩具",
+                "enSpuName": "Baby Plush Toy",
+                "ruSkuName": "Детская плюшевая игрушка",
+                "categoryName": "婴儿娃娃",
+                "brandName": "迪士尼",
+                "supplierName": "上海礼品公司",
+                "price": 32.00,
+                "imageUrl": "https://picsum.photos/seed/plush1/200/200.jpg",
+                "create_time": "2024-02-14T11:30:00Z",
+                "days_since_last_update": 25
+            }
+        ]
+
+        # Apply filters if any
+        if filters:
+            filtered_products = []
+            for product in sample_products:
+                include = True
+
+                # Check category filter
+                if 'category_name' in filters:
+                    if product['categoryName'] not in filters['category_name']:
+                        include = False
+
+                # Check brand filter
+                if 'brand_name' in filters:
+                    if product['brandName'] not in filters['brand_name']:
+                        include = False
+
+                # Check price range filter
+                if 'price_ranges' in filters:
+                    price = product['price']
+                    in_range = False
+                    for price_range in filters['price_ranges']:
+                        if price_range == '0-50' and price <= 50:
+                            in_range = True
+                        elif price_range == '50-100' and 50 < price <= 100:
+                            in_range = True
+                        elif price_range == '100-200' and 100 < price <= 200:
+                            in_range = True
+                        elif price_range == '200+' and price > 200:
+                            in_range = True
+                    if not in_range:
+                        include = False
+
+                if include:
+                    filtered_products.append(product)
+            sample_products = filtered_products
+
+        # Apply sorting
+        if sort_by == 'price_asc':
+            sample_products.sort(key=lambda x: x.get('price', 0))
+        elif sort_by == 'price_desc':
+            sample_products.sort(key=lambda x: x.get('price', 0), reverse=True)
+        elif sort_by == 'time_desc':
+            sample_products.sort(key=lambda x: x.get('create_time', ''), reverse=True)
+
+        # Convert to API response format
+        results = []
+        for i, product in enumerate(sample_products[:size]):
+            hit = {
+                "_id": str(product['skuId']),
+                "_score": round(random.uniform(1.5, 3.5), 3),
+                "_source": product
+            }
+            results.append(hit)
+
+        return results
+
+    def generate_mock_aggregations(self, aggregations, filters):
+        """Generate mock aggregation results."""
+        if not aggregations:
+            return {}
+
+        result = {}
+
+        for agg_name, agg_spec in aggregations.items():
+            agg_type = agg_spec.get('type', 'terms')
+
+            if agg_type == 'terms':
+                # Generate mock terms aggregation
+                if agg_name == 'category_name':
+                    buckets = [
+                        {"key": "芭比", "doc_count": random.randint(15, 35)},
+                        {"key": "儿童娃娃", "doc_count": random.randint(8, 20)},
+                        {"key": "积木", "doc_count": random.randint(5, 15)},
+                        {"key": "小汽车", "doc_count": random.randint(3, 12)},
+                        {"key": "婴儿娃娃", "doc_count": random.randint(4, 10)},
+                        {"key": "人物", "doc_count": random.randint(6, 18)}
+                    ]
+                elif agg_name == 'brand_name':
+                    buckets = [
+                        {"key": "美泰", "doc_count": random.randint(20, 40)},
+                        {"key": "乐高", "doc_count": random.randint(10, 25)},
+                        {"key": "迪士尼", "doc_count": random.randint(8, 20)},
+                        {"key": "多美卡", "doc_count": random.randint(5, 15)},
+                        {"key": "孩之宝", "doc_count": random.randint(6, 18)},
+                        {"key": "万代", "doc_count": random.randint(3, 10)}
+                    ]
+                elif agg_name == 'material_type':
+                    buckets = [
+                        {"key": "塑料", "doc_count": random.randint(40, 80)},
+                        {"key": "布绒", "doc_count": random.randint(8, 20)},
+                        {"key": "金属", "doc_count": random.randint(5, 15)},
+                        {"key": "木质", "doc_count": random.randint(3, 12)}
+                    ]
+                else:
+                    # Generic terms aggregation
+                    buckets = [
+                        {"key": f"选项{i+1}", "doc_count": random.randint(5, 25)}
+                        for i in range(5)
+                    ]
+
+                result[agg_name] = {
+                    "doc_count_error_upper_bound": 0,
+                    "sum_other_doc_count": random.randint(10, 50),
+                    "buckets": buckets
+                }
+
+            elif agg_type == 'range':
+                # Generate mock range aggregation (usually for price)
+                if agg_name == 'price_ranges':
+                    ranges = agg_spec.get('ranges', [])
+                    buckets = []
+                    for range_spec in ranges:
+                        key = range_spec.get('key', 'unknown')
+                        count = random.randint(5, 30)
+                        bucket_data = {"key": key, "doc_count": count}
+
+                        # Add range bounds
+                        if 'to' in range_spec:
+                            bucket_data['to'] = range_spec['to']
+                        if 'from' in range_spec:
+                            bucket_data['from'] = range_spec['from']
+
+                        buckets.append(bucket_data)
+
+                    result[agg_name] = {"buckets": buckets}
+
+        return result
+
+    def log_message(self, format, *args):
+        """Override to reduce log noise."""
+        pass
+
+def run_server():
+    """Run the API server."""
+    server_address = ('', 6002)
+    httpd = HTTPServer(server_address, SearchAPIHandler)
+    print("🚀 Simple Search API Server started!")
+    print("📍 API: http://localhost:6002")
+    print("🔍 Search endpoint: http://localhost:6002/search/")
+    print("🌐 Frontend should connect to: http://localhost:6002")
+    print("⏹️  Press Ctrl+C to stop")
+
+    try:
+        httpd.serve_forever()
+    except KeyboardInterrupt:
+        print("\n🛑 Server stopped")
+        httpd.server_close()
+
+def run_server():
+    """Run the API server - main entry point."""
+    server_address = ('', 6002)
+    httpd = HTTPServer(server_address, SearchAPIHandler)
+    print("🚀 Simple Search API Server started!")
+    print("📍 API: http://localhost:6002")
+    print("🔍 Search endpoint: http://localhost:6002/search/")
+    print("🌐 Frontend should connect to: http://localhost:6002")
+    print("⏹️  Press Ctrl+C to stop")
+
+    try:
+        httpd.serve_forever()
+    except KeyboardInterrupt:
+        print("\n🛑 Server stopped")
+        httpd.server_close()
+
+if __name__ == '__main__':
+    run_server()
\ No newline at end of file
diff --git a/test_aggregation_api.py b/test_aggregation_api.py
new file mode 100644
index 0000000..1974042
--- /dev/null
+++ b/test_aggregation_api.py
@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+"""
+Test script for aggregation functionality
+"""
+
+import requests
+import json
+
+API_BASE_URL = 'http://120.76.41.98:6002'
+
+def test_search_with_aggregations():
+    """Test search with aggregations"""
+
+    # Test data
+    test_query = {
+        "query": "玩具",
+        "size": 5,
+        "aggregations": {
+            "category_stats": {
+                "terms": {
+                    "field": "categoryName_keyword",
+                    "size": 10
+                }
+            },
+            "brand_stats": {
+                "terms": {
+                    "field": "brandName_keyword",
+                    "size": 10
+                }
+            },
+            "price_ranges": {
+                "range": {
+                    "field": "price",
+                    "ranges": [
+                        {"key": "0-50", "to": 50},
+                        {"key": "50-100", "from": 50, "to": 100},
+                        {"key": "100-200", "from": 100, "to": 200},
+                        {"key": "200+", "from": 200}
+                    ]
+                }
+            }
+        }
+    }
+
+    print("Testing search with aggregations...")
+    print(f"Query: {json.dumps(test_query, indent=2, ensure_ascii=False)}")
+
+    try:
+        response = requests.post(f"{API_BASE_URL}/search/",
+                               json=test_query,
+                               headers={'Content-Type': 'application/json'})
+
+        print(f"Status Code: {response.status_code}")
+
+        if response.ok:
+            data = response.json()
+            print(f"Found {data['total']} results in {data['took_ms']}ms")
+            print(f"Max Score: {data['max_score']}")
+
+            # Print aggregations
+            if data.get('aggregations'):
+                print("\nAggregations:")
+                for agg_name, agg_result in data['aggregations'].items():
+                    print(f"\n{agg_name}:")
+                    if 'buckets' in agg_result:
+                        for bucket in agg_result['buckets'][:5]:  # Show first 5 buckets
+                            print(f"  - {bucket['key']}: {bucket['doc_count']}")
+
+            # Print first few results
+            print(f"\nFirst 3 results:")
+            for i, hit in enumerate(data['hits'][:3]):
+                source = hit['_source']
+                print(f"\n{i+1}. {source.get('name', 'N/A')}")
+                print(f"   Category: {source.get('categoryName', 'N/A')}")
+                print(f"   Brand: {source.get('brandName', 'N/A')}")
+                print(f"   Price: {source.get('price', 'N/A')}")
+                print(f"   Score: {hit['_score']:.4f}")
+        else:
+            print(f"Error: {response.status_code}")
+            print(f"Response: {response.text}")
+
+    except Exception as e:
+        print(f"Request failed: {e}")
+
+def test_search_with_filters():
+    """Test search with filters"""
+
+    test_filters = {
+        "query": "玩具",
+        "size": 5,
+        "filters": {
+            "categoryName_keyword": ["玩具"],
+            "price_ranges": ["0-50", "50-100"]
+        }
+    }
+
+    print("\n\nTesting search with filters...")
+    print(f"Query: {json.dumps(test_filters, indent=2, ensure_ascii=False)}")
+
+    try:
+        response = requests.post(f"{API_BASE_URL}/search/",
+                               json=test_filters,
+                               headers={'Content-Type': 'application/json'})
+
+        print(f"Status Code: {response.status_code}")
+
+        if response.ok:
+            data = response.json()
+            print(f"Found {data['total']} results in {data['took_ms']}ms")
+
+            print(f"\nFirst 3 results:")
+            for i, hit in enumerate(data['hits'][:3]):
+                source = hit['_source']
+                print(f"\n{i+1}. {source.get('name', 'N/A')}")
+                print(f"   Category: {source.get('categoryName', 'N/A')}")
+                print(f"   Brand: {source.get('brandName', 'N/A')}")
+                print(f"   Price: {source.get('price', 'N/A')}")
+                print(f"   Score: {hit['_score']:.4f}")
+        else:
+            print(f"Error: {response.status_code}")
+            print(f"Response: {response.text}")
+
+    except Exception as e:
+        print(f"Request failed: {e}")
+
+def test_search_with_sorting():
+    """Test search with sorting"""
+
+    test_sort = {
+        "query": "玩具",
+        "size": 5,
+        "sort_by": "price",
+        "sort_order": "asc"
+    }
+
+    print("\n\nTesting search with sorting (price ascending)...")
+    print(f"Query: {json.dumps(test_sort, indent=2, ensure_ascii=False)}")
+
+    try:
+        response = requests.post(f"{API_BASE_URL}/search/",
+                               json=test_sort,
+                               headers={'Content-Type': 'application/json'})
+
+        print(f"Status Code: {response.status_code}")
+
+        if response.ok:
+            data = response.json()
+            print(f"Found {data['total']} results in {data['took_ms']}ms")
+
+            print(f"\nFirst 3 results (sorted by price):")
+            for i, hit in enumerate(data['hits'][:3]):
+                source = hit['_source']
+                print(f"\n{i+1}. {source.get('name', 'N/A')}")
+                print(f"   Price: {source.get('price', 'N/A')}")
+                print(f"   Score: {hit['_score']:.4f}")
+        else:
+            print(f"Error: {response.status_code}")
+            print(f"Response: {response.text}")
+
+    except Exception as e:
+        print(f"Request failed: {e}")
+
+if __name__ == "__main__":
+    test_search_with_aggregations()
+    test_search_with_filters()
+    test_search_with_sorting()
\ No newline at end of file
diff --git a/test_aggregation_functionality.py b/test_aggregation_functionality.py
new file mode 100644
index 0000000..0b12bbc
--- /dev/null
+++ b/test_aggregation_functionality.py
@@ -0,0 +1,236 @@
+#!/usr/bin/env python3
+"""
+Simple test script to verify aggregation functionality without external dependencies.
+"""
+
+import sys
+import os
+
+# Add the project root to the Python path
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+def test_es_query_builder_aggregations():
+    """Test the ES query builder aggregation methods."""
+    print("Testing ES Query Builder Aggregation Methods...")
+
+    # Import the query builder
+    try:
+        from search.es_query_builder import ESQueryBuilder
+        print("✓ ESQueryBuilder imported successfully")
+    except ImportError as e:
+        print(f"✗ Failed to import ESQueryBuilder: {e}")
+        return False
+
+    # Create a query builder instance
+    builder = ESQueryBuilder(
+        index_name="test_index",
+        match_fields=["name", "description"]
+    )
+
+    # Test basic aggregation
+    es_query = {"query": {"match_all": {}}}
+
+    # Test add_dynamic_aggregations
+    aggregations = {
+        "category_name": {
+            "type": "terms",
+            "field": "categoryName_keyword",
+            "size": 10
+        },
+        "price_ranges": {
+            "type": "range",
+            "field": "price",
+            "ranges": [
+                {"key": "0-50", "to": 50},
+                {"key": "50-100", "from": 50, "to": 100}
+            ]
+        }
+    }
+
+    result_query = builder.add_dynamic_aggregations(es_query, aggregations)
+
+    if "aggs" in result_query:
+        print("✓ Aggregations added to query")
+
+        # Check category aggregation
+        if "category_name" in result_query["aggs"]:
+            category_agg = result_query["aggs"]["category_name"]
+            if "terms" in category_agg and category_agg["terms"]["field"] == "categoryName_keyword":
+                print("✓ Category aggregation correctly configured")
+            else:
+                print("✗ Category aggregation incorrectly configured")
+                return False
+
+        # Check price range aggregation
+        if "price_ranges" in result_query["aggs"]:
+            price_agg = result_query["aggs"]["price_ranges"]
+            if "range" in price_agg and price_agg["range"]["field"] == "price":
+                print("✓ Price range aggregation correctly configured")
+            else:
+                print("✗ Price range aggregation incorrectly configured")
+                return False
+    else:
+        print("✗ No aggregations added to query")
+        return False
+
+    # Test sorting
+    result_query_asc = builder.add_sorting({}, "price_asc")
+    if "sort" in result_query_asc:
+        print("✓ Price ascending sort added")
+    else:
+        print("✗ Price ascending sort not added")
+        return False
+
+    result_query_desc = builder.add_sorting({}, "price_desc")
+    if "sort" in result_query_desc:
+        print("✓ Price descending sort added")
+    else:
+        print("✗ Price descending sort not added")
+        return False
+
+    result_query_time = builder.add_sorting({}, "time_desc")
+    if "sort" in result_query_time:
+        print("✓ Time descending sort added")
+    else:
+        print("✗ Time descending sort not added")
+        return False
+
+    return True
+
+
+def test_searcher_integration():
+    """Test searcher integration with new parameters."""
+    print("\nTesting Searcher Integration...")
+
+    try:
+        from search.searcher import Searcher
+        print("✓ Searcher imported successfully")
+    except ImportError as e:
+        print(f"✗ Failed to import Searcher: {e}")
+        return False
+
+    # We can't easily test the full searcher without ES, but we can check the method signature
+    import inspect
+    search_method = getattr(Searcher, 'search', None)
+
+    if search_method:
+        sig = inspect.signature(search_method)
+        params = list(sig.parameters.keys())
+
+        expected_params = ['query', 'size', 'from_', 'filters', 'min_score', 'aggregations', 'sort_by', 'context']
+        for param in expected_params:
+            if param in params:
+                print(f"✓ Parameter '{param}' found in search method")
+            else:
+                print(f"✗ Parameter '{param}' missing from search method")
+                return False
+    else:
+        print("✗ Search method not found in Searcher class")
+        return False
+
+    return True
+
+
+def test_api_route_integration():
+    """Test API route integration."""
+    print("\nTesting API Route Integration...")
+
+    try:
+        from api.routes.search import router
+        print("✓ Search router imported successfully")
+    except ImportError as e:
+        print(f"✗ Failed to import search router: {e}")
+        return False
+
+    # Check if the route exists
+    routes = [route.path for route in router.routes]
+    if "/" in routes:
+        print("✓ Main search route found")
+    else:
+        print("✗ Main search route not found")
+        return False
+
+    return True
+
+
+def test_configuration():
+    """Test configuration parsing."""
+    print("\nTesting Configuration...")
+
+    try:
+        from config import CustomerConfig
+        print("✓ CustomerConfig imported successfully")
+    except ImportError as e:
+        print(f"✗ Failed to import CustomerConfig: {e}")
+        return False
+
+    # Try to load the customer1 config
+    try:
+        config = CustomerConfig.load_from_file("config/schema/customer1_config.yaml")
+        print("✓ Customer1 configuration loaded successfully")
+
+        # Check if price field is in the configuration
+        field_names = [field.name for field in config.fields]
+        if "price" in field_names:
+            print("✓ Price field found in configuration")
+        else:
+            print("✗ Price field not found in configuration")
+            return False
+
+        # Check keyword fields for aggregations
+        if "categoryName_keyword" in field_names:
+            print("✓ Category keyword field found")
+        else:
+            print("✗ Category keyword field not found")
+            return False
+
+        if "brandName_keyword" in field_names:
+            print("✓ Brand keyword field found")
+        else:
+            print("✗ Brand keyword field not found")
+            return False
+
+    except Exception as e:
+        print(f"✗ Failed to load configuration: {e}")
+        return False
+
+    return True
+
+
+def main():
+    """Run all tests."""
+    print("=== Search Engine Aggregation Functionality Tests ===\n")
+
+    tests = [
+        test_es_query_builder_aggregations,
+        test_searcher_integration,
+        test_api_route_integration,
+        test_configuration
+    ]
+
+    passed = 0
+    total = len(tests)
+
+    for test in tests:
+        try:
+            if test():
+                passed += 1
+                print(f"✓ {test.__name__} PASSED")
+            else:
+                print(f"✗ {test.__name__} FAILED")
+        except Exception as e:
+            print(f"✗ {test.__name__} ERROR: {e}")
+
+    print(f"\n=== Test Results: {passed}/{total} tests passed ===")
+
+    if passed == total:
+        print("🎉 All tests passed! Aggregation functionality is ready.")
+        return True
+    else:
+        print("❌ Some tests failed. Please check the implementation.")
+        return False
+
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1)
\ No newline at end of file
diff --git a/test_complete_search.py b/test_complete_search.py
new file mode 100644
index 0000000..ded765f
--- /dev/null
+++ b/test_complete_search.py
@@ -0,0 +1,211 @@
+#!/usr/bin/env python3
+"""
+Complete test script simulating frontend search interaction
+"""
+
+import requests
+import json
+
+API_BASE_URL = 'http://120.76.41.98:6002'
+
+def test_complete_search_workflow():
+    """Test complete search workflow similar to frontend"""
+
+    print("=" * 60)
+    print("完整搜索流程测试")
+    print("=" * 60)
+
+    # Step 1: Initial search with aggregations
+    print("\n1️⃣ 初始搜索（带聚合功能）")
+    print("-" * 30)
+
+    search_request = {
+        "query": "芭比娃娃",
+        "size": 10,
+        "aggregations": {
+            "category_stats": {
+                "terms": {
+                    "field": "categoryName_keyword",
+                    "size": 10
+                }
+            },
+            "brand_stats": {
+                "terms": {
+                    "field": "brandName_keyword",
+                    "size": 10
+                }
+            },
+            "price_ranges": {
+                "range": {
+                    "field": "price",
+                    "ranges": [
+                        {"key": "0-50", "to": 50},
+                        {"key": "50-100", "from": 50, "to": 100},
+                        {"key": "100-200", "from": 100, "to": 200},
+                        {"key": "200+", "from": 200}
+                    ]
+                }
+            }
+        }
+    }
+
+    try:
+        response = requests.post(f"{API_BASE_URL}/search/", json=search_request)
+
+        if response.ok:
+            data = response.json()
+            print(f"✅ 找到 {data['total']} 个结果，耗时 {data['took_ms']}ms")
+
+            # Show aggregations results
+            if data.get('aggregations'):
+                print("\n📊 聚合结果:")
+
+                # Category aggregations
+                if 'category_stats' in data['aggregations']:
+                    print("  🏷️ 分类统计:")
+                    for bucket in data['aggregations']['category_stats']['buckets'][:3]:
+                        print(f"    - {bucket['key']}: {bucket['doc_count']} 个商品")
+
+                # Brand aggregations
+                if 'brand_stats' in data['aggregations']:
+                    print("  🏢 品牌统计:")
+                    for bucket in data['aggregations']['brand_stats']['buckets'][:3]:
+                        print(f"    - {bucket['key']}: {bucket['doc_count']} 个商品")
+
+                # Price ranges
+                if 'price_ranges' in data['aggregations']:
+                    print("  💰 价格分布:")
+                    for bucket in data['aggregations']['price_ranges']['buckets']:
+                        print(f"    - {bucket['key']}: {bucket['doc_count']} 个商品")
+
+            # Show sample results
+            print(f"\n🔍 前3个搜索结果:")
+            for i, hit in enumerate(data['hits'][:3]):
+                source = hit['_source']
+                price = source.get('price', 'N/A')
+                category = source.get('categoryName', 'N/A')
+                brand = source.get('brandName', 'N/A')
+                print(f"  {i+1}. {source.get('name', 'N/A')}")
+                print(f"     💰 价格: {price}")
+                print(f"     📁 分类: {category}")
+                print(f"     🏷️ 品牌: {brand}")
+                print(f"     ⭐ 评分: {hit['_score']:.3f}")
+                print()
+
+        else:
+            print(f"❌ 搜索失败: {response.status_code}")
+            print(f"错误信息: {response.text}")
+
+    except Exception as e:
+        print(f"❌ 请求异常: {e}")
+
+    # Step 2: Search with filters
+    print("\n2️⃣ 带过滤条件的搜索")
+    print("-" * 30)
+
+    filtered_search = {
+        "query": "芭比娃娃",
+        "size": 5,
+        "filters": {
+            "brandName_keyword": ["美泰"],
+            "price_ranges": ["50-100", "100-200"]
+        }
+    }
+
+    try:
+        response = requests.post(f"{API_BASE_URL}/search/", json=filtered_search)
+
+        if response.ok:
+            data = response.json()
+            print(f"✅ 过滤后找到 {data['total']} 个结果，耗时 {data['took_ms']}ms")
+            print("   🎯 过滤条件: 品牌=美泰, 价格=¥50-200")
+
+            print(f"\n💫 前3个过滤结果:")
+            for i, hit in enumerate(data['hits'][:3]):
+                source = hit['_source']
+                price = source.get('price', 'N/A')
+                category = source.get('categoryName', 'N/A')
+                brand = source.get('brandName', 'N/A')
+                print(f"  {i+1}. {source.get('name', 'N/A')}")
+                print(f"     💰 ¥{price} | 📁 {category} | 🏷️ {brand}")
+                print(f"     ⭐ 评分: {hit['_score']:.3f}")
+
+        else:
+            print(f"❌ 过滤搜索失败: {response.status_code}")
+
+    except Exception as e:
+        print(f"❌ 请求异常: {e}")
+
+    # Step 3: Search with sorting
+    print("\n3️⃣ 排序搜索")
+    print("-" * 30)
+
+    # Test price ascending
+    price_asc_search = {
+        "query": "芭比娃娃",
+        "size": 3,
+        "sort_by": "price",
+        "sort_order": "asc"
+    }
+
+    try:
+        response = requests.post(f"{API_BASE_URL}/search/", json=price_asc_search)
+
+        if response.ok:
+            data = response.json()
+            print(f"✅ 价格升序排序，找到 {data['total']} 个结果")
+            print("   📈 排序方式: 价格从低到高")
+
+            print(f"\n💵 价格排序结果:")
+            for i, hit in enumerate(data['hits']):
+                source = hit['_source']
+                price = source.get('price', 'N/A')
+                name = source.get('name', 'N/A')
+                print(f"  {i+1}. ¥{price} - {name}")
+
+        else:
+            print(f"❌ 排序搜索失败: {response.status_code}")
+
+    except Exception as e:
+        print(f"❌ 请求异常: {e}")
+
+    # Step 4: Test time sorting
+    print("\n4️⃣ 时间排序测试")
+    print("-" * 30)
+
+    time_sort_search = {
+        "query": "芭比娃娃",
+        "size": 3,
+        "sort_by": "create_time",
+        "sort_order": "desc"
+    }
+
+    try:
+        response = requests.post(f"{API_BASE_URL}/search/", json=time_sort_search)
+
+        if response.ok:
+            data = response.json()
+            print(f"✅ 时间降序排序，找到 {data['total']} 个结果")
+            print("   📅 排序方式: 上架时间从新到旧")
+
+            print(f"\n🕐 时间排序结果:")
+            for i, hit in enumerate(data['hits']):
+                source = hit['_source']
+                create_time = source.get('create_time', 'N/A')
+                name = source.get('name', 'N/A')
+                print(f"  {i+1}. {create_time} - {name}")
+
+        else:
+            print(f"❌ 时间排序失败: {response.status_code}")
+
+    except Exception as e:
+        print(f"❌ 请求异常: {e}")
+
+    print("\n" + "=" * 60)
+    print("🎉 搜索功能测试完成！")
+    print("✨ 前端访问地址: http://localhost:8080")
+    print("🔧 后端API地址: http://120.76.41.98:6002")
+    print("=" * 60)
+
+if __name__ == "__main__":
+    test_complete_search_workflow()
\ No newline at end of file
diff --git a/test_minimal_sort.py b/test_minimal_sort.py
new file mode 100644
index 0000000..946058c
--- /dev/null
+++ b/test_minimal_sort.py
@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+"""
+Minimal test to isolate sort issue
+"""
+
+import requests
+import json
+
+def test_minimal_sort():
+    """Test minimal sort case"""
+
+    base_url = "http://120.76.41.98:6002"
+
+    # Test 1: No sort parameters
+    print("Test 1: No sort parameters")
+    response = requests.post(f"{base_url}/search/", json={"query": "test", "size": 1})
+    print(f"Status: {response.status_code}")
+    print(f"Response: {response.text[:200]}...")
+
+    # Test 2: Empty sort_by
+    print("\nTest 2: Empty sort_by")
+    response = requests.post(f"{base_url}/search/", json={"query": "test", "size": 1, "sort_by": ""})
+    print(f"Status: {response.status_code}")
+    print(f"Response: {response.text[:200]}...")
+
+    # Test 3: sort_by only (no sort_order)
+    print("\nTest 3: sort_by only")
+    response = requests.post(f"{base_url}/search/", json={"query": "test", "size": 1, "sort_by": "create_time"})
+    print(f"Status: {response.status_code}")
+    print(f"Response: {response.text[:200]}...")
+
+    # Test 4: sort_order only (no sort_by)
+    print("\nTest 4: sort_order only")
+    response = requests.post(f"{base_url}/search/", json={"query": "test", "size": 1, "sort_order": "desc"})
+    print(f"Status: {response.status_code}")
+    print(f"Response: {response.text[:200]}...")
+
+    # Test 5: Both parameters with None values
+    print("\nTest 5: Both parameters with null values")
+    response = requests.post(f"{base_url}/search/", json={"query": "test", "size": 1, "sort_by": None, "sort_order": None})
+    print(f"Status: {response.status_code}")
+    print(f"Response: {response.text[:200]}...")
+
+if __name__ == "__main__":
+    test_minimal_sort()
\ No newline at end of file
diff --git a/tests/integration/test_aggregation_api.py b/tests/integration/test_aggregation_api.py
new file mode 100644
index 0000000..8540533
--- /dev/null
+++ b/tests/integration/test_aggregation_api.py
@@ -0,0 +1,256 @@
+"""
+Tests for aggregation API functionality.
+"""
+
+import pytest
+from fastapi.testclient import TestClient
+from api.app import app
+
+client = TestClient(app)
+
+
+@pytest.mark.integration
+@pytest.mark.api
+def test_search_with_aggregations():
+    """Test search with dynamic aggregations."""
+    request_data = {
+        "query": "芭比娃娃",
+        "size": 10,
+        "aggregations": {
+            "category_name": {
+                "type": "terms",
+                "field": "categoryName_keyword",
+                "size": 10
+            },
+            "brand_name": {
+                "type": "terms",
+                "field": "brandName_keyword",
+                "size": 10
+            },
+            "price_ranges": {
+                "type": "range",
+                "field": "price",
+                "ranges": [
+                    {"key": "0-50", "to": 50},
+                    {"key": "50-100", "from": 50, "to": 100},
+                    {"key": "100-200", "from": 100, "to": 200},
+                    {"key": "200+", "from": 200}
+                ]
+            }
+        }
+    }
+
+    response = client.post("/search/", json=request_data)
+
+    assert response.status_code == 200
+    data = response.json()
+
+    # Check basic search response structure
+    assert "hits" in data
+    assert "total" in data
+    assert "aggregations" in data
+    assert "query_info" in data
+
+    # Check aggregations structure
+    aggregations = data["aggregations"]
+
+    # Should have category aggregations
+    if "category_name" in aggregations:
+        assert "buckets" in aggregations["category_name"]
+        assert isinstance(aggregations["category_name"]["buckets"], list)
+
+    # Should have brand aggregations
+    if "brand_name" in aggregations:
+        assert "buckets" in aggregations["brand_name"]
+        assert isinstance(aggregations["brand_name"]["buckets"], list)
+
+    # Should have price range aggregations
+    if "price_ranges" in aggregations:
+        assert "buckets" in aggregations["price_ranges"]
+        assert isinstance(aggregations["price_ranges"]["buckets"], list)
+
+
+@pytest.mark.integration
+@pytest.mark.api
+def test_search_with_sorting():
+    """Test search with different sorting options."""
+
+    # Test price ascending
+    request_data = {
+        "query": "玩具",
+        "size": 5,
+        "sort_by": "price_asc"
+    }
+
+    response = client.post("/search/", json=request_data)
+    assert response.status_code == 200
+    data = response.json()
+
+    if data["hits"] and len(data["hits"]) > 1:
+        # Check if results are sorted by price (ascending)
+        prices = []
+        for hit in data["hits"]:
+            if "_source" in hit and "price" in hit["_source"]:
+                prices.append(hit["_source"]["price"])
+
+        if len(prices) > 1:
+            assert prices == sorted(prices), "Results should be sorted by price ascending"
+
+    # Test price descending
+    request_data["sort_by"] = "price_desc"
+    response = client.post("/search/", json=request_data)
+    assert response.status_code == 200
+    data = response.json()
+
+    if data["hits"] and len(data["hits"]) > 1:
+        prices = []
+        for hit in data["hits"]:
+            if "_source" in hit and "price" in hit["_source"]:
+                prices.append(hit["_source"]["price"])
+
+        if len(prices) > 1:
+            assert prices == sorted(prices, reverse=True), "Results should be sorted by price descending"
+
+    # Test time descending
+    request_data["sort_by"] = "time_desc"
+    response = client.post("/search/", json=request_data)
+    assert response.status_code == 200
+    data = response.json()
+
+    if data["hits"] and len(data["hits"]) > 1:
+        times = []
+        for hit in data["hits"]:
+            if "_source" in hit and "create_time" in hit["_source"]:
+                times.append(hit["_source"]["create_time"])
+
+        if len(times) > 1:
+            # Newer items should come first
+            assert times == sorted(times, reverse=True), "Results should be sorted by time descending"
+
+
+@pytest.mark.integration
+@pytest.mark.api
+def test_search_with_filters_and_aggregations():
+    """Test search with filters and aggregations together."""
+    request_data = {
+        "query": "玩具",
+        "size": 10,
+        "filters": {
+            "category_name": ["芭比"]
+        },
+        "aggregations": {
+            "brand_name": {
+                "type": "terms",
+                "field": "brandName_keyword",
+                "size": 10
+            }
+        }
+    }
+
+    response = client.post("/search/", json=request_data)
+    assert response.status_code == 200
+    data = response.json()
+
+    # Check that results are filtered
+    assert "hits" in data
+    for hit in data["hits"]:
+        if "_source" in hit and "categoryName" in hit["_source"]:
+            assert "芭比" in hit["_source"]["categoryName"]
+
+    # Check that aggregations are still present
+    assert "aggregations" in data
+
+
+@pytest.mark.integration
+@pytest.mark.api
+def test_search_without_aggregations():
+    """Test search without aggregations (default behavior)."""
+    request_data = {
+        "query": "玩具",
+        "size": 10
+    }
+
+    response = client.post("/search/", json=request_data)
+    assert response.status_code == 200
+    data = response.json()
+
+    # Should still have basic response structure
+    assert "hits" in data
+    assert "total" in data
+    assert "query_info" in data
+
+    # Aggregations might be empty or not present without explicit request
+    assert "aggregations" in data
+
+
+@pytest.mark.integration
+@pytest.mark.api
+def test_aggregation_edge_cases():
+    """Test aggregation edge cases."""
+
+    # Test with empty query
+    request_data = {
+        "query": "",
+        "size": 10,
+        "aggregations": {
+            "category_name": {
+                "type": "terms",
+                "field": "categoryName_keyword",
+                "size": 10
+            }
+        }
+    }
+
+    response = client.post("/search/", json=request_data)
+    # Should handle empty query gracefully
+    assert response.status_code in [200, 422]
+
+    # Test with invalid aggregation type
+    request_data = {
+        "query": "玩具",
+        "size": 10,
+        "aggregations": {
+            "invalid_agg": {
+                "type": "invalid_type",
+                "field": "categoryName_keyword",
+                "size": 10
+            }
+        }
+    }
+
+    response = client.post("/search/", json=request_data)
+    # Should handle invalid aggregation type gracefully
+    assert response.status_code in [200, 422]
+
+
+@pytest.mark.unit
+def test_aggregation_spec_validation():
+    """Test aggregation specification validation."""
+    from api.models import AggregationSpec
+
+    # Test valid aggregation spec
+    agg_spec = AggregationSpec(
+        field="categoryName_keyword",
+        type="terms",
+        size=10
+    )
+    assert agg_spec.field == "categoryName_keyword"
+    assert agg_spec.type == "terms"
+    assert agg_spec.size == 10
+
+    # Test range aggregation spec
+    range_agg = AggregationSpec(
+        field="price",
+        type="range",
+        ranges=[
+            {"key": "0-50", "to": 50},
+            {"key": "50-100", "from": 50, "to": 100}
+        ]
+    )
+    assert range_agg.field == "price"
+    assert range_agg.type == "range"
+    assert len(range_agg.ranges) == 2
+
+
+if __name__ == "__main__":
+    pytest.main([__file__])
\ No newline at end of file
--
libgit2 0.21.2