mongodb

package
v0.2.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 7, 2025 License: MIT Imports: 21 Imported by: 0

README

MongoDB Driver for RediORM

This driver provides MongoDB support for RediORM, enabling document database operations through the same familiar ORM interface.

Features

Core Capabilities
  • ✅ Full CRUD Operations - Create, Read, Update, Delete
  • ✅ Schema Management - Optional schema validation with JSON Schema
  • ✅ Transactions - Multi-document ACID transactions (MongoDB 4.0+, requires replica set)
  • ✅ Connection Management - Support for standard and SRV connection strings
  • ✅ Index Management - Create and manage indexes through schema definitions
  • ✅ Field Mapping - Automatic field name to column name conversion
  • ✅ Aggregation Queries - Full support for GROUP BY, HAVING with aggregation pipeline
MongoDB-Specific Features
  • ✅ SQL to MongoDB Translation - Write SQL queries that are automatically translated to MongoDB operations
  • ✅ Nested Documents - Full support for embedded documents
  • ✅ Array Fields - Native array field support
  • ✅ ObjectId Support - Native ObjectId type for _id fields
  • ✅ Aggregation Pipeline - Through raw queries and SQL translation
  • ✅ Document Validation - JSON Schema validation
  • ✅ Auto-increment IDs - Emulated using sequence collection
  • ✅ String Operators - Full regex support for startsWith, endsWith, contains
  • ✅ Schema Evolution - Automatic handling of missing nullable fields
  • ✅ Collection Validation - Existence checks for better error messages
  • 🔧 Geospatial Queries - Planned
  • 🔧 Text Search - Planned

Installation

import (
    "github.com/rediwo/redi-orm/database"
    _ "github.com/rediwo/redi-orm/drivers/mongodb"
)

Connection

Standard Connection
db, err := database.NewFromURI("mongodb://localhost:27017/myapp")
With Authentication
db, err := database.NewFromURI("mongodb://user:password@localhost:27017/myapp?authSource=admin")
MongoDB Atlas (SRV)
db, err := database.NewFromURI("mongodb+srv://user:password@cluster.mongodb.net/myapp")
Connection Options
  • authSource - Authentication database
  • replicaSet - Replica set name
  • readPreference - Read preference mode
  • w - Write concern
  • retryWrites - Enable retryable writes

Schema Definition

While MongoDB is schemaless, RediORM allows optional schema definitions for validation and type safety:

userSchema := schema.New("User").
    AddField(schema.Field{
        Name:       "_id",
        Type:       schema.FieldTypeObjectId,
        PrimaryKey: true,
    }).
    AddField(schema.Field{
        Name: "email",
        Type: schema.FieldTypeString,
        Unique: true,
    }).
    AddField(schema.Field{
        Name: "profile",
        Type: schema.FieldTypeDocument, // Nested document
    }).
    AddField(schema.Field{
        Name: "tags",
        Type: schema.FieldTypeStringArray, // Array field
    })
Supported Field Types
  • FieldTypeObjectId - MongoDB ObjectId
  • FieldTypeString - String
  • FieldTypeInt, FieldTypeInt64 - Integer types
  • FieldTypeFloat - Floating point
  • FieldTypeBool - Boolean
  • FieldTypeDateTime - Date/Time
  • FieldTypeDocument - Nested document (JSON)
  • FieldTypeArray - Generic array
  • FieldTypeStringArray, FieldTypeIntArray, etc. - Typed arrays
  • FieldTypeBinary - Binary data
  • FieldTypeDecimal128 - High precision decimal

Query Operations

Basic Queries

The MongoDB driver translates SQL-like queries to MongoDB operations:

// Find documents
users := db.Model("User").
    Select().
    Where("age").GreaterThan(18).
    Where("status").Equals("active").
    OrderBy("createdAt", types.DESC).
    Limit(10)

// The above translates to MongoDB filter:
// { age: { $gt: 18 }, status: "active" }
// With sort: { createdAt: -1 }
// And limit: 10
Aggregation Queries
// Group by with having clause
result := db.Model("Order").
    GroupBy("category").
    Having("SUM(amount) > ?", 1000).
    Select("category", "SUM(amount) as total", "COUNT(*) as count")

// Translates to MongoDB aggregation pipeline:
// [
//   { $group: { 
//     _id: "$category",
//     total: { $sum: "$amount" },
//     count: { $sum: 1 }
//   }},
//   { $match: { total: { $gt: 1000 } } }
// ]
Nested Field Queries
// Query nested fields using dot notation
users := db.Model("User").
    Select().
    Where("profile.location").Equals("San Francisco").
    Where("profile.age").GreaterThan(25)
Array Operations
// Query array fields
users := db.Model("User").
    Select().
    Where("tags").In("developer", "mongodb")

Raw Queries

The MongoDB driver supports both SQL and native MongoDB commands:

SQL Queries
// SQL queries are automatically translated to MongoDB
var users []map[string]any
err := db.Raw("SELECT * FROM users WHERE age > ? ORDER BY name", 18).Find(ctx, &users)

// Complex SQL with JOINs (translated to $lookup)
err := db.Raw(`
    SELECT u.*, COUNT(p.id) as post_count 
    FROM users u 
    LEFT JOIN posts p ON u.id = p.user_id 
    GROUP BY u.id
`).Find(ctx, &results)
Native MongoDB Commands
// Execute MongoDB commands directly
result, err := db.Raw(`{
    "aggregate": "users",
    "pipeline": [
        { "$match": { "age": { "$gte": 18 } } },
        { "$group": {
            "_id": "$location",
            "count": { "$sum": 1 }
        }}
    ]
}`).Exec(ctx)

// Find with native MongoDB syntax
var user map[string]any
err := db.Raw(`{
    "find": "users",
    "filter": {"email": "john@example.com"},
    "limit": 1
}`).FindOne(ctx, &user)

Transactions

MongoDB supports multi-document transactions (requires MongoDB 4.0+ and replica set):

err := db.Transaction(ctx, func(tx types.Transaction) error {
    // All operations in transaction
    _, err := tx.Model("User").Insert(userData).Exec(ctx)
    if err != nil {
        return err // Automatic rollback
    }
    
    _, err = tx.Model("Order").Insert(orderData).Exec(ctx)
    return err
})

Indexes

Define indexes through schema:

schema.AddIndex(schema.Index{
    Name:   "email_idx",
    Fields: []string{"email"},
    Unique: true,
})

// Compound index
schema.AddIndex(schema.Index{
    Name:   "location_age_idx",
    Fields: []string{"location", "age"},
})

Limitations and Differences

Feature Limitations
  1. No Savepoints - MongoDB doesn't support savepoints in transactions
  2. Limited JOIN Support - JOINs are translated to $lookup (only LEFT JOIN supported)
  3. Schema Migrations - MongoDB is schemaless, no ALTER TABLE equivalent
  4. Foreign Keys - No native foreign key constraints
Behavioral Differences
  1. String Matching - MongoDB uses case-sensitive regex by default
  2. NULL Handling - MongoDB treats missing fields and null differently
  3. Transactions - Require MongoDB 4.0+ with replica set
  4. Auto-increment - Emulated using a sequence collection

Query Translation

The driver translates SQL-like conditions to MongoDB filters:

SQL Operation MongoDB Equivalent
= value { field: value }
!= value { field: { $ne: value } }
> value { field: { $gt: value } }
>= value { field: { $gte: value } }
< value { field: { $lt: value } }
<= value { field: { $lte: value } }
IN (...) { field: { $in: [...] } }
NOT IN (...) { field: { $nin: [...] } }
LIKE '%text%' { field: { $regex: ".*text.*" } }
IS NULL { field: null }
IS NOT NULL { field: { $ne: null } }

Best Practices

  1. Use Indexes - Create indexes for frequently queried fields
  2. Limit Projections - Select only needed fields to reduce network traffic
  3. Batch Operations - Use InsertMany for bulk inserts
  4. Connection Pooling - The driver handles connection pooling automatically
  5. Schema Validation - Use schemas for data integrity even though MongoDB is flexible
  6. Query Choice - Use SQL for simple queries, native MongoDB for complex aggregations
  7. Transactions - Ensure replica set is configured for transaction support

Example

package main

import (
    "context"
    "log"
    
    "github.com/rediwo/redi-orm/database"
    _ "github.com/rediwo/redi-orm/drivers/mongodb"
    "github.com/rediwo/redi-orm/schema"
)

func main() {
    // Connect
    db, err := database.NewFromURI("mongodb://localhost:27017/myapp")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()
    
    ctx := context.Background()
    if err := db.Connect(ctx); err != nil {
        log.Fatal(err)
    }
    
    // Define schema
    userSchema := schema.New("User").
        AddField(schema.Field{
            Name:       "_id",
            Type:       schema.FieldTypeObjectId,
            PrimaryKey: true,
        }).
        AddField(schema.Field{
            Name: "name",
            Type: schema.FieldTypeString,
        }).
        AddField(schema.Field{
            Name: "email",
            Type: schema.FieldTypeString,
            Unique: true,
        })
    
    // Register and sync
    db.AddSchema(userSchema)
    if err := db.SyncSchemas(ctx); err != nil {
        log.Fatal(err)
    }
    
    // Use the model
    User := db.Model("User")
    
    // Insert
    result, err := User.Insert(map[string]any{
        "name": "John Doe",
        "email": "john@example.com",
    }).Exec(ctx)
    
    // Query
    var users []map[string]any
    err = User.Select().
        Where("name").Contains("John").
        FindMany(ctx, &users)
}

Contributing

When adding features to the MongoDB driver:

  1. Maintain compatibility with the RediORM interface
  2. Add appropriate type conversions for BSON types
  3. Include tests for MongoDB-specific features
  4. Document any limitations or differences from SQL databases
  5. Update this README with new features

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func NewMongoDBDeleteQuery 

func NewMongoDBDeleteQuery(baseQuery *query.ModelQueryImpl, db *MongoDB, fieldMapper types.FieldMapper, modelName string) types.DeleteQuery

NewMongoDBDeleteQuery creates a new MongoDB delete query

func NewMongoDBInsertQuery 

func NewMongoDBInsertQuery(baseQuery *query.ModelQueryImpl, data any, db *MongoDB, fieldMapper types.FieldMapper, modelName string) types.InsertQuery

NewMongoDBInsertQuery creates a new MongoDB insert query

func NewMongoDBModelQuery 

func NewMongoDBModelQuery(db *MongoDB, modelName string) types.ModelQuery

NewMongoDBModelQuery creates a new MongoDB model query

func NewMongoDBSelectQuery 

func NewMongoDBSelectQuery(baseQuery *query.ModelQueryImpl, fieldNames []string, db *MongoDB, fieldMapper types.FieldMapper, modelName string) types.SelectQuery

NewMongoDBSelectQuery creates a new MongoDB select query

func NewMongoDBUpdateQuery 

func NewMongoDBUpdateQuery(baseQuery *query.ModelQueryImpl, data any, db *MongoDB, fieldMapper types.FieldMapper, modelName string) types.UpdateQuery

NewMongoDBUpdateQuery creates a new MongoDB update query

func NewMongoDBaggregationQuery 

func NewMongoDBaggregationQuery(baseQuery *query.ModelQueryImpl, db *MongoDB, fieldMapper types.FieldMapper, modelName string) types.AggregationQuery

NewMongoDBaggregationQuery creates a new MongoDB aggregation query

Types

type MongoDB 

type MongoDB struct {
	*base.Driver
	// contains filtered or unexported fields
}

MongoDB implements the Database interface for MongoDB

func NewMongoDB 

func NewMongoDB(nativeURI string) (*MongoDB, error)

NewMongoDB creates a new MongoDB database instance The uri parameter should be a MongoDB connection string

func (*MongoDB) Begin 

func (m *MongoDB) Begin(ctx context.Context) (types.Transaction, error)

Begin starts a new transaction

func (*MongoDB) Close 

func (m *MongoDB) Close() error

Close closes the MongoDB connection

func (*MongoDB) Connect 

func (m *MongoDB) Connect(ctx context.Context) error

Connect establishes connection to MongoDB

func (*MongoDB) CreateModel 

func (m *MongoDB) CreateModel(ctx context.Context, modelName string) error

CreateModel creates a collection for the given model

func (*MongoDB) DropModel 

func (m *MongoDB) DropModel(ctx context.Context, modelName string) error

DropModel drops the collection for the given model

func (*MongoDB) Exec 

func (m *MongoDB) Exec(query string, args ...any) (sql.Result, error)

Exec is not directly applicable to MongoDB

func (*MongoDB) GetCapabilities 

func (m *MongoDB) GetCapabilities() types.DriverCapabilities

GetCapabilities returns driver capabilities

func (*MongoDB) GetDriverType 

func (m *MongoDB) GetDriverType() string

GetDriverType returns the database driver type

func (*MongoDB) GetMigrator 

func (m *MongoDB) GetMigrator() types.DatabaseMigrator

GetMigrator returns a migrator for MongoDB

func (*MongoDB) Model 

func (m *MongoDB) Model(modelName string) types.ModelQuery

Model creates a new model query

func (*MongoDB) Ping 

func (m *MongoDB) Ping(ctx context.Context) error

Ping checks if the database is reachable

func (*MongoDB) Query 

func (m *MongoDB) Query(query string, args ...any) (*sql.Rows, error)

Query is not directly applicable to MongoDB

func (*MongoDB) QueryRow 

func (m *MongoDB) QueryRow(query string, args ...any) *sql.Row

QueryRow is not directly applicable to MongoDB

func (*MongoDB) Raw 

func (m *MongoDB) Raw(command string, args ...any) types.RawQuery

Raw creates a new raw query

func (*MongoDB) SyncSchemas 

func (m *MongoDB) SyncSchemas(ctx context.Context) error

SyncSchemas synchronizes all loaded schemas with the database

func (*MongoDB) Transaction 

func (m *MongoDB) Transaction(ctx context.Context, fn func(tx types.Transaction) error) error

Transaction executes a function within a transaction

type MongoDBAndCondition 

type MongoDBAndCondition struct {
	Left  types.Condition
	Right types.Condition
	// contains filtered or unexported fields
}

MongoDBAndCondition represents AND logic

func (*MongoDBAndCondition) And 

func (c *MongoDBAndCondition) And(condition types.Condition) types.Condition

func (*MongoDBAndCondition) Not 

func (c *MongoDBAndCondition) Not() types.Condition

func (*MongoDBAndCondition) Or 

func (c *MongoDBAndCondition) Or(condition types.Condition) types.Condition

func (*MongoDBAndCondition) ToSQL 

func (c *MongoDBAndCondition) ToSQL(ctx *types.ConditionContext) (string, []any)

type MongoDBCapabilities 

type MongoDBCapabilities struct{}

MongoDBCapabilities implements DriverCapabilities for MongoDB

func NewMongoDBCapabilities 

func NewMongoDBCapabilities() *MongoDBCapabilities

NewMongoDBCapabilities creates new MongoDB capabilities

func (*MongoDBCapabilities) GetBooleanLiteral 

func (c *MongoDBCapabilities) GetBooleanLiteral(value bool) string

Type conversion

func (*MongoDBCapabilities) GetDriverType 

func (c *MongoDBCapabilities) GetDriverType() types.DriverType

Driver identification

func (*MongoDBCapabilities) GetNullsOrderingSQL 

func (c *MongoDBCapabilities) GetNullsOrderingSQL(direction types.Order, nullsFirst bool) string

func (*MongoDBCapabilities) GetPlaceholder 

func (c *MongoDBCapabilities) GetPlaceholder(index int) string

func (*MongoDBCapabilities) GetSupportedSchemes 

func (c *MongoDBCapabilities) GetSupportedSchemes() []string

func (*MongoDBCapabilities) IsNoSQL 

func (c *MongoDBCapabilities) IsNoSQL() bool

NoSQL features

func (*MongoDBCapabilities) IsSystemIndex 

func (c *MongoDBCapabilities) IsSystemIndex(indexName string) bool

Index/Table detection

func (*MongoDBCapabilities) IsSystemTable 

func (c *MongoDBCapabilities) IsSystemTable(tableName string) bool

func (*MongoDBCapabilities) NeedsTypeConversion 

func (c *MongoDBCapabilities) NeedsTypeConversion() bool

func (*MongoDBCapabilities) QuoteIdentifier 

func (c *MongoDBCapabilities) QuoteIdentifier(name string) string

Identifier quoting

func (*MongoDBCapabilities) RequiresLimitForOffset 

func (c *MongoDBCapabilities) RequiresLimitForOffset() bool

func (*MongoDBCapabilities) SupportsAggregationPipeline 

func (c *MongoDBCapabilities) SupportsAggregationPipeline() bool

func (*MongoDBCapabilities) SupportsArrayFields 

func (c *MongoDBCapabilities) SupportsArrayFields() bool

func (*MongoDBCapabilities) SupportsDefaultValues 

func (c *MongoDBCapabilities) SupportsDefaultValues() bool

func (*MongoDBCapabilities) SupportsDistinctOn 

func (c *MongoDBCapabilities) SupportsDistinctOn() bool

func (*MongoDBCapabilities) SupportsNestedDocuments 

func (c *MongoDBCapabilities) SupportsNestedDocuments() bool

func (*MongoDBCapabilities) SupportsReturning 

func (c *MongoDBCapabilities) SupportsReturning() bool

SQL dialect features (mostly not applicable to MongoDB)

func (*MongoDBCapabilities) SupportsTransactions 

func (c *MongoDBCapabilities) SupportsTransactions() bool

type MongoDBCommand 

type MongoDBCommand struct {
	Operation    string   `json:"operation"`              // "insert", "find", "update", "delete", "aggregate"
	Collection   string   `json:"collection"`             // Collection name
	Documents    []any    `json:"documents,omitempty"`    // For insert operations
	Filter       bson.M   `json:"filter,omitempty"`       // For find/update/delete
	Update       bson.M   `json:"update,omitempty"`       // For update operations
	Pipeline     []bson.M `json:"pipeline,omitempty"`     // For aggregate operations
	Options      bson.M   `json:"options,omitempty"`      // Operation options (limit, skip, sort, etc.)
	Fields       []string `json:"fields,omitempty"`       // Field names for projection
	LastInsertID int64    `json:"lastInsertId,omitempty"` // For passing generated ID from insert query
}

MongoDBCommand represents a MongoDB operation command

func (*MongoDBCommand) FromJSON 

func (c *MongoDBCommand) FromJSON(jsonStr string) error

FromJSON parses a JSON string into a MongoDBCommand

func (*MongoDBCommand) ToJSON 

func (c *MongoDBCommand) ToJSON() (string, error)

ToJSON converts the command to JSON string

type MongoDBCondition 

type MongoDBCondition struct {
	// contains filtered or unexported fields
}

MongoDBCondition represents a MongoDB-specific condition

func (*MongoDBCondition) And 

func (c *MongoDBCondition) And(condition types.Condition) types.Condition

And combines conditions with AND logic

func (*MongoDBCondition) Not 

func (c *MongoDBCondition) Not() types.Condition

Not negates the condition

func (*MongoDBCondition) Or 

func (c *MongoDBCondition) Or(condition types.Condition) types.Condition

Or combines conditions with OR logic

func (*MongoDBCondition) ToSQL 

func (c *MongoDBCondition) ToSQL(ctx *types.ConditionContext) (string, []any)

ToSQL generates MongoDB command JSON instead of SQL

type MongoDBConditionContext 

type MongoDBConditionContext struct {
	ModelName    string
	QueryBuilder *MongoDBQueryBuilder
}

MongoDBConditionContext provides context for condition conversion

type MongoDBDeleteQuery 

type MongoDBDeleteQuery struct {
	*query.DeleteQueryImpl
	// contains filtered or unexported fields
}

MongoDBDeleteQuery implements DeleteQuery for MongoDB

func (*MongoDBDeleteQuery) BuildSQL 

func (q *MongoDBDeleteQuery) BuildSQL() (string, []any, error)

BuildSQL builds a MongoDB delete command instead of SQL

func (*MongoDBDeleteQuery) Exec 

func (q *MongoDBDeleteQuery) Exec(ctx context.Context) (types.Result, error)

Exec executes the delete query

func (*MongoDBDeleteQuery) ExecAndReturn 

func (q *MongoDBDeleteQuery) ExecAndReturn(ctx context.Context, dest any) error

ExecAndReturn is not supported for MongoDB deletes

func (*MongoDBDeleteQuery) Returning 

func (q *MongoDBDeleteQuery) Returning(fieldNames ...string) types.DeleteQuery

func (*MongoDBDeleteQuery) WhereCondition 

func (q *MongoDBDeleteQuery) WhereCondition(condition types.Condition) types.DeleteQuery

Override DeleteQuery methods to preserve MongoDB-specific type

type MongoDBFieldCondition 

type MongoDBFieldCondition struct {
	// contains filtered or unexported fields
}

MongoDBFieldCondition represents a MongoDB-specific field condition

func NewMongoDBFieldCondition 

func NewMongoDBFieldCondition(modelName, fieldName string, db *MongoDB) *MongoDBFieldCondition

NewMongoDBFieldCondition creates a MongoDB field condition

func (*MongoDBFieldCondition) Between 

func (f *MongoDBFieldCondition) Between(min, max any) types.Condition

Between creates a between condition

func (*MongoDBFieldCondition) Contains 

func (f *MongoDBFieldCondition) Contains(value string) types.Condition

Contains creates a contains condition (regex)

func (*MongoDBFieldCondition) EndsWith 

func (f *MongoDBFieldCondition) EndsWith(value string) types.Condition

EndsWith creates an ends-with condition (regex)

func (*MongoDBFieldCondition) Equals 

func (f *MongoDBFieldCondition) Equals(value any) types.Condition

Equals creates an equality condition

func (*MongoDBFieldCondition) GetFieldName 

func (f *MongoDBFieldCondition) GetFieldName() string

GetFieldName returns the field name

func (*MongoDBFieldCondition) GetModelName 

func (f *MongoDBFieldCondition) GetModelName() string

GetModelName returns the model name

func (*MongoDBFieldCondition) GreaterThan 

func (f *MongoDBFieldCondition) GreaterThan(value any) types.Condition

GreaterThan creates a greater-than condition

func (*MongoDBFieldCondition) GreaterThanOrEqual 

func (f *MongoDBFieldCondition) GreaterThanOrEqual(value any) types.Condition

GreaterThanOrEqual creates a greater-than-or-equal condition

func (*MongoDBFieldCondition) In 

func (f *MongoDBFieldCondition) In(values ...any) types.Condition

In creates an IN condition

func (*MongoDBFieldCondition) IsNotNull 

func (f *MongoDBFieldCondition) IsNotNull() types.Condition

IsNotNull creates an IS NOT NULL condition

func (*MongoDBFieldCondition) IsNull 

func (f *MongoDBFieldCondition) IsNull() types.Condition

IsNull creates an IS NULL condition

func (*MongoDBFieldCondition) LessThan 

func (f *MongoDBFieldCondition) LessThan(value any) types.Condition

LessThan creates a less-than condition

func (*MongoDBFieldCondition) LessThanOrEqual 

func (f *MongoDBFieldCondition) LessThanOrEqual(value any) types.Condition

LessThanOrEqual creates a less-than-or-equal condition

func (*MongoDBFieldCondition) Like 

func (f *MongoDBFieldCondition) Like(pattern string) types.Condition

Like creates a LIKE condition (converted to regex)

func (*MongoDBFieldCondition) NotEquals 

func (f *MongoDBFieldCondition) NotEquals(value any) types.Condition

NotEquals creates a not-equals condition

func (*MongoDBFieldCondition) NotIn 

func (f *MongoDBFieldCondition) NotIn(values ...any) types.Condition

NotIn creates a NOT IN condition

func (*MongoDBFieldCondition) StartsWith 

func (f *MongoDBFieldCondition) StartsWith(value string) types.Condition

StartsWith creates a starts-with condition (regex)

type MongoDBFieldMapper 

type MongoDBFieldMapper struct {
	types.FieldMapper
	// contains filtered or unexported fields
}

MongoDBFieldMapper wraps the base field mapper to handle MongoDB-specific field mapping

func NewMongoDBFieldMapper 

func NewMongoDBFieldMapper(baseMapper types.FieldMapper, db *MongoDB) *MongoDBFieldMapper

NewMongoDBFieldMapper creates a new MongoDB field mapper

func (*MongoDBFieldMapper) BuildMongoDBFilter 

func (m *MongoDBFieldMapper) BuildMongoDBFilter(modelName string, conditions map[string]any) (bson.M, error)

BuildMongoDBFilter builds a MongoDB filter from schema field names This properly handles primary key field mapping to _id

func (*MongoDBFieldMapper) ColumnToSchema 

func (m *MongoDBFieldMapper) ColumnToSchema(modelName, columnName string) (string, error)

ColumnToSchema maps a MongoDB column name to schema field name This handles the special case of _id being mapped back to primary key fields

func (*MongoDBFieldMapper) GenerateNextSequenceValue 

func (m *MongoDBFieldMapper) GenerateNextSequenceValue(modelName string) (int64, error)

GenerateNextSequenceValue generates the next sequence value for auto-increment fields Uses MongoDB's findOneAndUpdate with upsert to atomically increment sequence values

func (*MongoDBFieldMapper) GetAutoIncrementFieldName 

func (m *MongoDBFieldMapper) GetAutoIncrementFieldName(modelName string) string

GetAutoIncrementFieldName returns the field name for auto-increment sequences

func (*MongoDBFieldMapper) GetSequenceCollectionName 

func (m *MongoDBFieldMapper) GetSequenceCollectionName() string

GetSequenceCollectionName returns the name of the sequence collection

func (*MongoDBFieldMapper) MapColumnToSchemaData 

func (m *MongoDBFieldMapper) MapColumnToSchemaData(modelName string, data map[string]any) (map[string]any, error)

MapColumnToSchemaData maps a data map from column names to schema field names This handles MongoDB's _id field mapping back to primary key fields

func (*MongoDBFieldMapper) MapSchemaToColumnData 

func (m *MongoDBFieldMapper) MapSchemaToColumnData(modelName string, data map[string]any) (map[string]any, error)

MapSchemaToColumnData maps a data map from schema field names to column names This handles MongoDB's _id field mapping and composite primary keys

func (*MongoDBFieldMapper) ModelToTable 

func (m *MongoDBFieldMapper) ModelToTable(modelName string) (string, error)

ModelToTable converts model name to MongoDB collection name This handles cases where schemas haven't been registered yet

func (*MongoDBFieldMapper) RegisterSchema 

func (m *MongoDBFieldMapper) RegisterSchema(modelName string, s *schema.Schema)

RegisterSchema registers a schema with the underlying field mapper

func (*MongoDBFieldMapper) SchemaToColumn 

func (m *MongoDBFieldMapper) SchemaToColumn(modelName, fieldName string) (string, error)

SchemaToColumn maps a schema field name to MongoDB column name This handles the special case of primary keys being mapped to _id

type MongoDBInsertQuery 

type MongoDBInsertQuery struct {
	*query.InsertQueryImpl
	// contains filtered or unexported fields
}

MongoDBInsertQuery implements InsertQuery for MongoDB

func (*MongoDBInsertQuery) BuildSQL 

func (q *MongoDBInsertQuery) BuildSQL() (string, []any, error)

BuildSQL builds a MongoDB insert command instead of SQL

func (*MongoDBInsertQuery) Exec 

func (q *MongoDBInsertQuery) Exec(ctx context.Context) (types.Result, error)

Exec executes the insert query

func (*MongoDBInsertQuery) ExecAndReturn 

func (q *MongoDBInsertQuery) ExecAndReturn(ctx context.Context, dest any) error

ExecAndReturn is not supported for MongoDB inserts

func (*MongoDBInsertQuery) GetDatabase 

func (q *MongoDBInsertQuery) GetDatabase() types.Database

GetDatabase returns the database

func (*MongoDBInsertQuery) GetFieldMapper 

func (q *MongoDBInsertQuery) GetFieldMapper() types.FieldMapper

GetFieldMapper returns the field mapper

func (*MongoDBInsertQuery) GetModelName 

func (q *MongoDBInsertQuery) GetModelName() string

GetModelName returns the model name from the base query

func (*MongoDBInsertQuery) Values 

func (q *MongoDBInsertQuery) Values(data ...any) types.InsertQuery

Values adds more data to insert

type MongoDBMigrator 

type MongoDBMigrator struct {
	// contains filtered or unexported fields
}

MongoDBMigrator implements DatabaseMigrator for MongoDB

func NewMongoDBMigrator 

func NewMongoDBMigrator(database *mongo.Database, db *MongoDB) *MongoDBMigrator

NewMongoDBMigrator creates a new MongoDB migrator

func (*MongoDBMigrator) ApplyMigration 

func (m *MongoDBMigrator) ApplyMigration(sql string) error

ApplyMigration executes a migration command

func (*MongoDBMigrator) CompareSchema 

func (m *MongoDBMigrator) CompareSchema(existingTable *types.TableInfo, desiredSchema any) (*types.MigrationPlan, error)

CompareSchema compares existing collection with desired schema

func (*MongoDBMigrator) GenerateAddColumnSQL 

func (m *MongoDBMigrator) GenerateAddColumnSQL(tableName string, field any) (string, error)

GenerateAddColumnSQL is not applicable for MongoDB

func (*MongoDBMigrator) GenerateCreateIndexSQL 

func (m *MongoDBMigrator) GenerateCreateIndexSQL(tableName, indexName string, columns []string, unique bool) string

GenerateCreateIndexSQL generates index creation command

func (*MongoDBMigrator) GenerateCreateTableSQL 

func (m *MongoDBMigrator) GenerateCreateTableSQL(schema any) (string, error)

GenerateCreateTableSQL generates collection creation (not applicable for MongoDB)

func (*MongoDBMigrator) GenerateDropColumnSQL 

func (m *MongoDBMigrator) GenerateDropColumnSQL(tableName, columnName string) ([]string, error)

GenerateDropColumnSQL is not applicable for MongoDB

func (*MongoDBMigrator) GenerateDropIndexSQL 

func (m *MongoDBMigrator) GenerateDropIndexSQL(indexName string) string

GenerateDropIndexSQL generates index drop command

func (*MongoDBMigrator) GenerateDropTableSQL 

func (m *MongoDBMigrator) GenerateDropTableSQL(tableName string) string

GenerateDropTableSQL generates collection drop command

func (*MongoDBMigrator) GenerateMigrationSQL 

func (m *MongoDBMigrator) GenerateMigrationSQL(plan *types.MigrationPlan) ([]string, error)

GenerateMigrationSQL generates migration commands

func (*MongoDBMigrator) GenerateModifyColumnSQL 

func (m *MongoDBMigrator) GenerateModifyColumnSQL(change types.ColumnChange) ([]string, error)

GenerateModifyColumnSQL is not applicable for MongoDB

func (*MongoDBMigrator) GetDatabaseType 

func (m *MongoDBMigrator) GetDatabaseType() string

GetDatabaseType returns the database type

func (*MongoDBMigrator) GetTableInfo 

func (m *MongoDBMigrator) GetTableInfo(tableName string) (*types.TableInfo, error)

GetTableInfo returns information about a collection

func (*MongoDBMigrator) GetTables 

func (m *MongoDBMigrator) GetTables() ([]string, error)

GetTables returns all collections in the database

type MongoDBModelQuery 

type MongoDBModelQuery struct {
	*query.ModelQueryImpl
	// contains filtered or unexported fields
}

MongoDBModelQuery extends the base ModelQuery with MongoDB-specific implementations

func (*MongoDBModelQuery) Aggregate 

func (q *MongoDBModelQuery) Aggregate() types.AggregationQuery

Aggregate creates a MongoDB-specific aggregation query

func (*MongoDBModelQuery) Avg 

func (q *MongoDBModelQuery) Avg(ctx context.Context, fieldName string) (float64, error)

Avg calculates the average value of a numeric field using MongoDB aggregation

func (*MongoDBModelQuery) Count 

func (q *MongoDBModelQuery) Count(ctx context.Context) (int64, error)

Override execution methods to ensure MongoDB-specific queries are used

func (*MongoDBModelQuery) Delete 

func (q *MongoDBModelQuery) Delete() types.DeleteQuery

Delete creates a MongoDB-specific delete query

func (*MongoDBModelQuery) Exists 

func (q *MongoDBModelQuery) Exists(ctx context.Context) (bool, error)

func (*MongoDBModelQuery) GroupBy 

func (q *MongoDBModelQuery) GroupBy(fieldNames ...string) types.ModelQuery

func (*MongoDBModelQuery) Having 

func (q *MongoDBModelQuery) Having(condition types.Condition) types.ModelQuery

func (*MongoDBModelQuery) Include 

func (q *MongoDBModelQuery) Include(relations ...string) types.ModelQuery

func (*MongoDBModelQuery) Insert 

func (q *MongoDBModelQuery) Insert(data any) types.InsertQuery

Insert creates a MongoDB-specific insert query

func (*MongoDBModelQuery) Limit 

func (q *MongoDBModelQuery) Limit(limit int) types.ModelQuery

func (*MongoDBModelQuery) Max 

func (q *MongoDBModelQuery) Max(ctx context.Context, fieldName string) (any, error)

Max finds the maximum value of a field using MongoDB aggregation

func (*MongoDBModelQuery) Min 

func (q *MongoDBModelQuery) Min(ctx context.Context, fieldName string) (any, error)

Min finds the minimum value of a field using MongoDB aggregation

func (*MongoDBModelQuery) Offset 

func (q *MongoDBModelQuery) Offset(offset int) types.ModelQuery

func (*MongoDBModelQuery) OrderBy 

func (q *MongoDBModelQuery) OrderBy(fieldName string, direction types.Order) types.ModelQuery

func (*MongoDBModelQuery) Select 

func (q *MongoDBModelQuery) Select(fieldNames ...string) types.SelectQuery

Select creates a MongoDB-specific select query

func (*MongoDBModelQuery) Sum 

func (q *MongoDBModelQuery) Sum(ctx context.Context, fieldName string) (float64, error)

Sum calculates the sum of a numeric field using MongoDB aggregation

func (*MongoDBModelQuery) Update 

func (q *MongoDBModelQuery) Update(data any) types.UpdateQuery

Update creates a MongoDB-specific update query

func (*MongoDBModelQuery) Where 

func (q *MongoDBModelQuery) Where(fieldName string) types.FieldCondition

Where creates a MongoDB-specific field condition

func (*MongoDBModelQuery) WhereCondition 

func (q *MongoDBModelQuery) WhereCondition(condition types.Condition) types.ModelQuery

Override condition methods to preserve MongoDB-specific type

func (*MongoDBModelQuery) WhereRaw 

func (q *MongoDBModelQuery) WhereRaw(sql string, args ...any) types.ModelQuery

func (*MongoDBModelQuery) With 

func (q *MongoDBModelQuery) With(relations ...string) types.ModelQuery

type MongoDBNotCondition 

type MongoDBNotCondition struct {
	Condition types.Condition
	// contains filtered or unexported fields
}

MongoDBNotCondition represents NOT logic

func (*MongoDBNotCondition) And 

func (c *MongoDBNotCondition) And(condition types.Condition) types.Condition

func (*MongoDBNotCondition) Not 

func (c *MongoDBNotCondition) Not() types.Condition

func (*MongoDBNotCondition) Or 

func (c *MongoDBNotCondition) Or(condition types.Condition) types.Condition

func (*MongoDBNotCondition) ToSQL 

func (c *MongoDBNotCondition) ToSQL(ctx *types.ConditionContext) (string, []any)

type MongoDBOrCondition 

type MongoDBOrCondition struct {
	Left  types.Condition
	Right types.Condition
	// contains filtered or unexported fields
}

MongoDBOrCondition represents OR logic

func (*MongoDBOrCondition) And 

func (c *MongoDBOrCondition) And(condition types.Condition) types.Condition

func (*MongoDBOrCondition) Not 

func (c *MongoDBOrCondition) Not() types.Condition

func (*MongoDBOrCondition) Or 

func (c *MongoDBOrCondition) Or(condition types.Condition) types.Condition

func (*MongoDBOrCondition) ToSQL 

func (c *MongoDBOrCondition) ToSQL(ctx *types.ConditionContext) (string, []any)

type MongoDBQueryBuilder 

type MongoDBQueryBuilder struct {
	// contains filtered or unexported fields
}

MongoDBQueryBuilder converts SQL-like queries to MongoDB operations

func NewMongoDBQueryBuilder 

func NewMongoDBQueryBuilder(db *MongoDB) *MongoDBQueryBuilder

NewMongoDBQueryBuilder creates a new query builder

func (*MongoDBQueryBuilder) ConditionToFilter 

func (qb *MongoDBQueryBuilder) ConditionToFilter(condition types.Condition, modelName string) (bson.M, error)

ConditionToFilter converts a types.Condition to MongoDB filter

func (*MongoDBQueryBuilder) ConvertOrderBy 

func (qb *MongoDBQueryBuilder) ConvertOrderBy(orderBys []types.OrderByClause, modelName string) (bson.D, error)

ConvertOrderBy converts order by fields to MongoDB sort

func (*MongoDBQueryBuilder) ConvertProjection 

func (qb *MongoDBQueryBuilder) ConvertProjection(fields []string, modelName string) (bson.M, error)

ConvertProjection converts selected fields to MongoDB projection

type MongoDBRawQuery 

type MongoDBRawQuery struct {
	// contains filtered or unexported fields
}

MongoDBRawQuery implements RawQuery for MongoDB

func NewMongoDBRawQuery 

func NewMongoDBRawQuery(database *mongo.Database, session mongo.Session, mongoDb *MongoDB, command string, args ...any) *MongoDBRawQuery

NewMongoDBRawQuery creates a new raw query

func (*MongoDBRawQuery) Exec 

func (q *MongoDBRawQuery) Exec(ctx context.Context) (types.Result, error)

Exec executes a MongoDB command

func (*MongoDBRawQuery) Find 

func (q *MongoDBRawQuery) Find(ctx context.Context, dest any) error

Find executes a query and returns multiple results

func (*MongoDBRawQuery) FindOne 

func (q *MongoDBRawQuery) FindOne(ctx context.Context, dest any) error

FindOne executes a query and returns a single result

type MongoDBSQLTranslator 

type MongoDBSQLTranslator struct {
	// contains filtered or unexported fields
}

MongoDBSQLTranslator converts SQL AST to MongoDB commands

func NewMongoDBSQLTranslator 

func NewMongoDBSQLTranslator(db *MongoDB) *MongoDBSQLTranslator

NewMongoDBSQLTranslator creates a new MongoDB SQL translator

func (*MongoDBSQLTranslator) SetArgs 

func (t *MongoDBSQLTranslator) SetArgs(args []any)

SetArgs sets the SQL parameters for substitution

func (*MongoDBSQLTranslator) TranslateToCommand 

func (t *MongoDBSQLTranslator) TranslateToCommand(stmt sql.SQLStatement) (*MongoDBCommand, error)

TranslateToCommand translates SQL AST to MongoDB command

type MongoDBSelectQuery 

type MongoDBSelectQuery struct {
	*query.SelectQueryImpl
	// contains filtered or unexported fields
}

MongoDBSelectQuery implements SelectQuery for MongoDB

func (*MongoDBSelectQuery) BuildSQL 

func (q *MongoDBSelectQuery) BuildSQL() (string, []any, error)

BuildSQL builds a MongoDB find/aggregate command instead of SQL

func (*MongoDBSelectQuery) Count 

func (q *MongoDBSelectQuery) Count(ctx context.Context) (int64, error)

Count executes a count query

func (*MongoDBSelectQuery) Distinct 

func (q *MongoDBSelectQuery) Distinct() types.SelectQuery

func (*MongoDBSelectQuery) DistinctOn 

func (q *MongoDBSelectQuery) DistinctOn(fieldNames ...string) types.SelectQuery

func (*MongoDBSelectQuery) FindFirst 

func (q *MongoDBSelectQuery) FindFirst(ctx context.Context, dest any) error

FindFirst executes the query and returns the first result

func (*MongoDBSelectQuery) FindMany 

func (q *MongoDBSelectQuery) FindMany(ctx context.Context, dest any) error

FindMany executes the query and returns multiple results

func (*MongoDBSelectQuery) GetConditions 

func (q *MongoDBSelectQuery) GetConditions() []types.Condition

Helper functions to access query properties

func (*MongoDBSelectQuery) GetDatabase 

func (q *MongoDBSelectQuery) GetDatabase() types.Database

Helper methods to access base query fields

func (*MongoDBSelectQuery) GetDistinct 

func (q *MongoDBSelectQuery) GetDistinct() bool

func (*MongoDBSelectQuery) GetFieldMapper 

func (q *MongoDBSelectQuery) GetFieldMapper() types.FieldMapper

func (*MongoDBSelectQuery) GetGroupBy 

func (q *MongoDBSelectQuery) GetGroupBy() []string

func (*MongoDBSelectQuery) GetIncludes 

func (q *MongoDBSelectQuery) GetIncludes() []string

func (*MongoDBSelectQuery) GetLimit 

func (q *MongoDBSelectQuery) GetLimit() int

func (*MongoDBSelectQuery) GetModelName 

func (q *MongoDBSelectQuery) GetModelName() string

func (*MongoDBSelectQuery) GetOffset 

func (q *MongoDBSelectQuery) GetOffset() int

func (*MongoDBSelectQuery) GetOrderBy 

func (q *MongoDBSelectQuery) GetOrderBy() []types.OrderByClause

func (*MongoDBSelectQuery) GetSelectedFields 

func (q *MongoDBSelectQuery) GetSelectedFields() []string

func (*MongoDBSelectQuery) GroupBy 

func (q *MongoDBSelectQuery) GroupBy(fieldNames ...string) types.SelectQuery

func (*MongoDBSelectQuery) Having 

func (q *MongoDBSelectQuery) Having(condition types.Condition) types.SelectQuery

func (*MongoDBSelectQuery) Include 

func (q *MongoDBSelectQuery) Include(relations ...string) types.SelectQuery

func (*MongoDBSelectQuery) IncludeWithOptions 

func (q *MongoDBSelectQuery) IncludeWithOptions(path string, opt *types.IncludeOption) types.SelectQuery

func (*MongoDBSelectQuery) Limit 

func (q *MongoDBSelectQuery) Limit(limit int) types.SelectQuery

func (*MongoDBSelectQuery) Offset 

func (q *MongoDBSelectQuery) Offset(offset int) types.SelectQuery

func (*MongoDBSelectQuery) OrderBy 

func (q *MongoDBSelectQuery) OrderBy(fieldName string, direction types.Order) types.SelectQuery

func (*MongoDBSelectQuery) WhereCondition 

func (q *MongoDBSelectQuery) WhereCondition(condition types.Condition) types.SelectQuery

Override SelectQuery methods to preserve MongoDB-specific type

type MongoDBTransaction 

type MongoDBTransaction struct {
	// contains filtered or unexported fields
}

MongoDBTransaction implements the Transaction interface for MongoDB

func NewMongoDBTransaction 

func NewMongoDBTransaction(session mongo.Session, db *MongoDB) *MongoDBTransaction

NewMongoDBTransaction creates a new MongoDB transaction

func (*MongoDBTransaction) Commit 

func (t *MongoDBTransaction) Commit(ctx context.Context) error

Commit commits the transaction

func (*MongoDBTransaction) CreateMany 

func (t *MongoDBTransaction) CreateMany(ctx context.Context, modelName string, data []any) (types.Result, error)

CreateMany performs batch insert within the transaction

func (*MongoDBTransaction) DeleteMany 

func (t *MongoDBTransaction) DeleteMany(ctx context.Context, modelName string, condition types.Condition) (types.Result, error)

DeleteMany performs batch delete within the transaction

func (*MongoDBTransaction) Model 

func (t *MongoDBTransaction) Model(modelName string) types.ModelQuery

Model creates a new model query within the transaction

func (*MongoDBTransaction) Raw 

func (t *MongoDBTransaction) Raw(sql string, args ...any) types.RawQuery

Raw creates a new raw query within the transaction

func (*MongoDBTransaction) Rollback 

func (t *MongoDBTransaction) Rollback(ctx context.Context) error

Rollback rolls back the transaction

func (*MongoDBTransaction) RollbackTo 

func (t *MongoDBTransaction) RollbackTo(ctx context.Context, name string) error

RollbackTo rolls back to a savepoint (not supported in MongoDB)

func (*MongoDBTransaction) Savepoint 

func (t *MongoDBTransaction) Savepoint(ctx context.Context, name string) error

Savepoint creates a savepoint (not supported in MongoDB)

func (*MongoDBTransaction) UpdateMany 

func (t *MongoDBTransaction) UpdateMany(ctx context.Context, modelName string, condition types.Condition, data any) (types.Result, error)

UpdateMany performs batch update within the transaction

type MongoDBURIParser 

type MongoDBURIParser struct{}

MongoDBURIParser handles MongoDB URI parsing

func NewMongoDBURIParser 

func NewMongoDBURIParser() *MongoDBURIParser

NewMongoDBURIParser creates a new MongoDB URI parser

func (*MongoDBURIParser) GetDriverType 

func (p *MongoDBURIParser) GetDriverType() string

GetDriverType returns the driver type for this parser

func (*MongoDBURIParser) GetSupportedSchemes 

func (p *MongoDBURIParser) GetSupportedSchemes() []string

GetSupportedSchemes returns the URI schemes supported by this parser

func (*MongoDBURIParser) ParseURI 

func (p *MongoDBURIParser) ParseURI(uri string) (string, error)

ParseURI parses a MongoDB URI and returns the native MongoDB connection string

type MongoDBUpdateQuery 

type MongoDBUpdateQuery struct {
	*query.UpdateQueryImpl
	// contains filtered or unexported fields
}

MongoDBUpdateQuery implements UpdateQuery for MongoDB

func (*MongoDBUpdateQuery) BuildSQL 

func (q *MongoDBUpdateQuery) BuildSQL() (string, []any, error)

BuildSQL builds a MongoDB update command instead of SQL

func (*MongoDBUpdateQuery) Decrement 

func (q *MongoDBUpdateQuery) Decrement(fieldName string, value int64) types.UpdateQuery

func (*MongoDBUpdateQuery) Exec 

func (q *MongoDBUpdateQuery) Exec(ctx context.Context) (types.Result, error)

Exec executes the update query

func (*MongoDBUpdateQuery) ExecAndReturn 

func (q *MongoDBUpdateQuery) ExecAndReturn(ctx context.Context, dest any) error

ExecAndReturn is not supported for MongoDB updates

func (*MongoDBUpdateQuery) Increment 

func (q *MongoDBUpdateQuery) Increment(fieldName string, value int64) types.UpdateQuery

func (*MongoDBUpdateQuery) Returning 

func (q *MongoDBUpdateQuery) Returning(fieldNames ...string) types.UpdateQuery

func (*MongoDBUpdateQuery) Set 

func (q *MongoDBUpdateQuery) Set(data any) types.UpdateQuery

Override UpdateQuery methods to preserve MongoDB-specific type

func (*MongoDBUpdateQuery) WhereCondition 

func (q *MongoDBUpdateQuery) WhereCondition(condition types.Condition) types.UpdateQuery

type MongoDBaggregationQuery 

type MongoDBaggregationQuery struct {
	*query.AggregationQueryImpl
	// contains filtered or unexported fields
}

MongoDBaggregationQuery implements AggregationQuery for MongoDB

func (*MongoDBaggregationQuery) Avg 

func (q *MongoDBaggregationQuery) Avg(fieldName string, alias string) types.AggregationQuery

func (*MongoDBaggregationQuery) BuildSQL 

func (q *MongoDBaggregationQuery) BuildSQL() (string, []any, error)

func (*MongoDBaggregationQuery) Count 

func (q *MongoDBaggregationQuery) Count(fieldName string, alias string) types.AggregationQuery

func (*MongoDBaggregationQuery) CountAll 

func (q *MongoDBaggregationQuery) CountAll(alias string) types.AggregationQuery

func (*MongoDBaggregationQuery) Exec 

func (q *MongoDBaggregationQuery) Exec(ctx context.Context, dest any) error

Override execution method to use MongoDB aggregation pipeline

func (*MongoDBaggregationQuery) GetAggregationOrders 

func (q *MongoDBaggregationQuery) GetAggregationOrders() []aggregationOrder

func (*MongoDBaggregationQuery) GetAggregations 

func (q *MongoDBaggregationQuery) GetAggregations() []aggregation

func (*MongoDBaggregationQuery) GetConditions 

func (q *MongoDBaggregationQuery) GetConditions() []types.Condition

func (*MongoDBaggregationQuery) GetGroupBy 

func (q *MongoDBaggregationQuery) GetGroupBy() []string

Helper methods to access aggregation query internals

func (*MongoDBaggregationQuery) GetHaving 

func (q *MongoDBaggregationQuery) GetHaving() types.Condition

func (*MongoDBaggregationQuery) GetLimit 

func (q *MongoDBaggregationQuery) GetLimit() int

func (*MongoDBaggregationQuery) GetModelName 

func (q *MongoDBaggregationQuery) GetModelName() string

func (*MongoDBaggregationQuery) GetOffset 

func (q *MongoDBaggregationQuery) GetOffset() int

func (*MongoDBaggregationQuery) GetOrderBy 

func (q *MongoDBaggregationQuery) GetOrderBy() []OrderClause

func (*MongoDBaggregationQuery) GroupBy 

func (q *MongoDBaggregationQuery) GroupBy(fieldNames ...string) types.AggregationQuery

Override methods to preserve MongoDB type

func (*MongoDBaggregationQuery) Having 

func (q *MongoDBaggregationQuery) Having(condition types.Condition) types.AggregationQuery

func (*MongoDBaggregationQuery) Limit 

func (q *MongoDBaggregationQuery) Limit(limit int) types.AggregationQuery

func (*MongoDBaggregationQuery) Max 

func (q *MongoDBaggregationQuery) Max(fieldName string, alias string) types.AggregationQuery

func (*MongoDBaggregationQuery) Min 

func (q *MongoDBaggregationQuery) Min(fieldName string, alias string) types.AggregationQuery

func (*MongoDBaggregationQuery) Offset 

func (q *MongoDBaggregationQuery) Offset(offset int) types.AggregationQuery

func (*MongoDBaggregationQuery) OrderBy 

func (q *MongoDBaggregationQuery) OrderBy(fieldName string, direction types.Order) types.AggregationQuery

func (*MongoDBaggregationQuery) OrderByAggregation 

func (q *MongoDBaggregationQuery) OrderByAggregation(aggregationType string, fieldName string, direction types.Order) types.AggregationQuery

func (*MongoDBaggregationQuery) Select 

func (q *MongoDBaggregationQuery) Select(fieldNames ...string) types.AggregationQuery

func (*MongoDBaggregationQuery) Sum 

func (q *MongoDBaggregationQuery) Sum(fieldName string, alias string) types.AggregationQuery

func (*MongoDBaggregationQuery) Where 

func (q *MongoDBaggregationQuery) Where(fieldName string) types.FieldCondition

func (*MongoDBaggregationQuery) WhereCondition 

func (q *MongoDBaggregationQuery) WhereCondition(condition types.Condition) types.AggregationQuery

type OrderClause 

type OrderClause struct {
	FieldName string
	Direction types.Order
}

type SubqueryExecutor 

type SubqueryExecutor struct {
	// contains filtered or unexported fields
}

SubqueryExecutor handles execution of SQL subqueries in MongoDB

func NewSubqueryExecutor 

func NewSubqueryExecutor(db *MongoDB, translator *MongoDBSQLTranslator) *SubqueryExecutor

NewSubqueryExecutor creates a new subquery executor

func (*SubqueryExecutor) ExecuteSubquery 

func (e *SubqueryExecutor) ExecuteSubquery(ctx context.Context, subquery *sql.SelectStatement, args []any) ([]any, error)

ExecuteSubquery executes a subquery and returns the result values

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.