> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-fbfa8bee.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Démarrage rapide de DataStore

> Prise en main de DataStore : installation, migration en une ligne depuis pandas et utilisation de base

Prenez en main DataStore en quelques minutes. Ce guide présente l'installation, la migration depuis pandas et les bases de son utilisation.

<div id="installation">
  ## Installation
</div>

Installez chDB avec pip :

```bash theme={null}
pip install "chdb>=4.0"
```

Pour les dépendances facultatives :

```bash theme={null}
# For pandas DataFrame support
pip install "chdb[pandas]>=4.0"

# For PyArrow support
pip install "chdb[arrow]>=4.0"

# All optional dependencies
pip install "chdb[all]>=4.0"
```

<div id="verify">
  ### Vérifier l’installation
</div>

```python theme={null}
import chdb
print(chdb.__version__)  # Should print 4.x.x or higher

from chdb import datastore as pd
print("DataStore ready!")
```

<div id="migration">
  ## Migration en une ligne depuis Pandas
</div>

Pour commencer à utiliser DataStore, il vous suffit de modifier votre instruction d’import :

```python theme={null}
# Before (pandas)
import pandas as pd

# After (DataStore)
from chdb import datastore as pd
```

C’est tout ! Votre code pandas existant utilisera désormais DataStore et profitera de l’optimisation SQL.

<div id="migration-example">
  ### Exemple de migration
</div>

```python theme={null}
from pathlib import Path
Path("employees.csv").write_text("""\
name,age,city,salary,department,dept_id,status,email
Alice,28,NYC,75000,Engineering,1,active,alice@company.com
Bob,35,LA,85000,Engineering,1,active,bob@company.com
Charlie,52,NYC,95000,Product,2,active,charlie@company.com
Diana,32,SF,70000,Design,3,active,diana@company.com
Eve,23,LA,48000,Product,2,inactive,eve@company.com
""")

# Original pandas code
import pandas as pd

df = pd.read_csv("employees.csv")
result = (df[df['salary'] > 50000]
          .groupby('department')['salary']
          .agg(['mean', 'count'])
          .sort_values('mean', ascending=False))
print(result)

# DataStore version - just change the import!
from chdb import datastore as pd

df = pd.read_csv("employees.csv")
result = (df[df['salary'] > 50000]
          .groupby('department')['salary']
          .agg(['mean', 'count'])
          .sort_values('mean', ascending=False))
print(result)  # Same result, faster execution!
```

<div id="basic-usage">
  ## Utilisation de base
</div>

<div id="creating">
  ### Créer un DataStore
</div>

```python theme={null}
from chdb import datastore as pd

# From a dictionary
ds = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 35],
    'city': ['NYC', 'LA', 'NYC']
})

# From a pandas DataFrame
import pandas
pdf = pandas.DataFrame({'a': [1, 2, 3], 'b': [4, 5, 6]})
ds = pd.DataFrame(pdf)

# From a CSV file
ds = pd.read_csv("data.csv")

# From a Parquet file (recommended for large datasets)
ds = pd.read_parquet("data.parquet")
```

<div id="filtering">
  ### Filtrer les données
</div>

```python theme={null}
from chdb import datastore as pd

ds = pd.read_csv("employees.csv")

# Single condition
senior = ds[ds['age'] > 30]

# Multiple conditions (AND)
senior_nyc = ds[(ds['age'] > 30) & (ds['city'] == 'NYC')]

# Multiple conditions (OR)
young_or_senior = ds[(ds['age'] < 25) | (ds['age'] > 50)]

# Using filter method (SQL-style)
result = ds.filter(ds['salary'] > 50000)
```

<div id="selecting">
  ### Sélection des colonnes
</div>

```python theme={null}
# Pandas style
subset = ds[['name', 'age']]

# SQL style
subset = ds.select('name', 'age')
```

<div id="sorting">
  ### Tri
</div>

```python theme={null}
# Pandas style
sorted_ds = ds.sort_values('salary', ascending=False)

# SQL style
sorted_ds = ds.sort('salary', ascending=False)
```

<div id="groupby">
  ### Regroupement et agrégation
</div>

```python theme={null}
from pathlib import Path
Path("sales.csv").write_text("""\
region,product,category,amount,quantity,price,date,order_id
East,Widget,Electronics,5200,10,120,2024-01-15,1001
West,Gadget,Electronics,800,5,160,2024-02-20,1002
East,Gizmo,Home,6500,3,100,2024-03-10,1003
North,Widget,Electronics,4500,6,150,2024-06-18,1004
West,Gadget,Electronics,2000,8,250,2024-09-14,1005
""")

from chdb import datastore as pd

ds = pd.read_csv("sales.csv")

# Group by single column
by_region = ds.groupby('region')['amount'].sum()

# Group by multiple columns
by_region_product = ds.groupby(['region', 'product']).agg({
    'amount': ['sum', 'mean'],
    'quantity': 'sum'
})

# Multiple aggregations
summary = ds.groupby('category').agg({
    'price': ['min', 'max', 'mean'],
    'quantity': 'sum'
})
```

<div id="joining">
  ### Jointure entre DataStores
</div>

```python theme={null}
from pathlib import Path
Path("departments.csv").write_text("""\
dept_id,department_name
1,Engineering
2,Product
3,Design
""")

from chdb import datastore as pd

employees = pd.read_csv("employees.csv")
departments = pd.read_csv("departments.csv")

# Inner join
result = employees.join(departments, on='dept_id', how='inner')

# Left join
result = employees.join(departments, on='dept_id', how='left')

# Using merge (pandas style)
result = pd.merge(employees, departments, on='dept_id')
```

<div id="results">
  ## Obtenir des résultats
</div>

DataStore utilise l’évaluation paresseuse : les opérations ne sont exécutées que lorsque vous avez besoin des résultats.

<div id="execution-triggers">
  ### Déclencher l’exécution
</div>

```python theme={null}
# Automatic triggers
print(ds)           # Displaying results
len(ds)             # Getting row count
ds.columns          # Accessing properties
list(ds)            # Converting to list

# Explicit conversion
df = ds.to_df()     # Convert to pandas DataFrame
df = ds.to_pandas() # Same as to_df()
```

<div id="view-sql">
  ### Afficher le SQL généré
</div>

```python title="Query" theme={null}
# See what SQL DataStore will execute
query = ds.filter(ds['age'] > 25).groupby('city').agg({'salary': 'mean'})
print(query.to_sql())
```

```sql title="Response" theme={null}
SELECT city, AVG(salary) AS mean
FROM file('data.csv', 'CSVWithNames')
WHERE age > 25
GROUP BY city
```

<div id="data-sources">
  ## Travailler avec différentes sources de données
</div>

<div id="local-files">
  ### Fichiers locaux
</div>

```python theme={null}
from chdb import datastore as pd

# CSV
ds = pd.read_csv("data.csv")

# Parquet (best performance)
ds = pd.read_parquet("data.parquet")

# JSON
ds = pd.read_json("data.json")
```

<div id="cloud-storage">
  ### Stockage dans le cloud
</div>

```python theme={null}
from chdb.datastore import DataStore

# S3 (anonymous)
ds = DataStore.uri("s3://bucket/data.parquet?nosign=true")

# S3 (with credentials)
ds = DataStore.from_s3(
    "s3://bucket/data.parquet",
    access_key_id="KEY",
    secret_access_key="SECRET"
)

# HTTP/HTTPS
ds = DataStore.uri("https://example.com/data.csv")
```

<div id="databases">
  ### Bases de données
</div>

```python theme={null}
from chdb.datastore import DataStore

# MySQL
ds = DataStore.from_mysql(
    host="localhost",
    database="mydb",
    table="users",
    user="root",
    password="pass"
)

# PostgreSQL
ds = DataStore.from_postgresql(
    host="localhost",
    database="mydb",
    table="users",
    user="postgres",
    password="pass"
)

# Using URI
ds = DataStore.uri("mysql://user:pass@localhost:3306/mydb/users")
```

<div id="accessors">
  ## Opérations sur chaîne de caractères et DateTime
</div>

<div id="string-ops">
  ### Opérations sur les chaînes de caractères
</div>

```python theme={null}
# All pandas .str methods work
ds['name_upper'] = ds['name'].str.upper()
ds['name_len'] = ds['name'].str.len()
ds['has_a'] = ds['name'].str.contains('a')
```

<div id="datetime-ops">
  ### Opérations sur DateTime
</div>

```python theme={null}
# All pandas .dt methods work
ds['year'] = ds['date'].dt.year
ds['month'] = ds['date'].dt.month
ds['day_of_week'] = ds['date'].dt.dayofweek
```

<div id="extensions">
  ### Extensions de ClickHouse
</div>

```python theme={null}
# URL parsing (not available in pandas!)
ds['domain'] = ds['url'].url.domain()

# JSON extraction
ds['user_name'] = ds['json_data'].json.get_string('name')

# IP address operations
ds['is_ipv4'] = ds['ip_addr'].ip.is_ipv4_string()
```

<div id="best-practices">
  ## Bonnes pratiques
</div>

<div id="use-parquet-for-large-files">
  ### 1. Utilisez Parquet pour les fichiers volumineux
</div>

```python theme={null}
# CSV - slower, reads entire file
ds = pd.read_csv("large_data.csv")

# Parquet - faster, columnar format, reads only needed columns
ds = pd.read_parquet("large_data.parquet")
```

<div id="filter-early">
  ### 2. Filtrez le plus tôt possible
</div>

```python theme={null}
# Good - filter first, then aggregate
result = (ds
    .filter(ds['date'] >= '2024-01-01')
    .groupby('category')['amount'].sum()
)

# Less optimal - aggregate first
result = ds.groupby('category')['amount'].sum()
```

<div id="select-only-needed-columns">
  ### 3. Sélectionnez uniquement les colonnes nécessaires
</div>

```python theme={null}
# Good - select specific columns
result = ds.select('name', 'age', 'city').filter(ds['age'] > 25)

# Less optimal - work with all columns
result = ds.filter(ds['age'] > 25)
```

<div id="use-sql-for-complex-operations">
  ### 4. Utiliser SQL pour les opérations complexes
</div>

```python theme={null}
# For complex queries, use SQL directly
ds = DataStore()
result = ds.sql("""
    SELECT category, 
           SUM(amount) as total,
           COUNT(*) as count,
           AVG(amount) as avg
    FROM file('sales.csv', 'CSVWithNames')
    WHERE date >= '2024-01-01'
    GROUP BY category
    HAVING total > 10000
    ORDER BY total DESC
    LIMIT 10
""")
```

<div id="next-steps">
  ## Étapes suivantes
</div>

* Découvrez toutes les [méthodes de fabrique](/fr/products/chdb/datastore/factory-methods) pour créer des DataStore
* Explorez la [création de requêtes](/fr/products/chdb/datastore/query-building) pour effectuer des opérations de type SQL
* Consultez les [accesseurs](/fr/products/chdb/datastore/accessors) pour les chaînes, datetime, et plus encore
* Lisez le [Guide des performances](/fr/products/chdb/guides/pandas-performance) pour des conseils d'optimisation