Remove commented code

Author: erikdubbelboer

filter/converter.go

@@ -163,133 +163,3 @@ func (c *Converter) columnName(column string) string {
 	}
 	return fmt.Sprintf(`%q->>'%s'`, c.nestedColumn, column)
 }
-
-/*
-type Converter struct {
-	nestedColumn     string
-	nestedExemptions []string
-}
-
-func NewConverter(options ...Option) *Converter {
-	converter := &Converter{}
-	for _, option := range options {
-		option(converter)
-	}
-	return converter
-}
-
-func (c *Converter) Convert(filter []byte) (conditions string, values []any, err error) {
-	expr, err := c.parse(filter)
-	if err != nil {
-		return "", nil, fmt.Errorf("failed to parse filter: %w", err)
-	}
-	conditions, values, err = expr.ToPostgresWhereClause()
-	if err != nil {
-		return "", nil, fmt.Errorf("failed to convert expression to where clause: %w", err)
-	}
-	return
-}
-
-type expression interface {
-	ToPostgresWhereClause() (string, []any, error)
-}
-
-type compoundExpression struct {
-	expressions []expression
-	operator    string
-}
-
-func (e compoundExpression) ToPostgresWhereClause() (string, []any, error) {
-	values := []any{}
-	conditions := []string{}
-	for _, expr := range e.expressions {
-		condition, value, err := expr.ToPostgresWhereClause()
-		if err != nil {
-			return "", nil, fmt.Errorf("failed to convert expression to where clause: %w", err)
-		}
-		conditions = append(conditions, condition)
-		values = append(values, value...)
-	}
-	return "(" + strings.Join(conditions, " AND ") + ")", values, nil
-}
-
-type scalarExpression struct {
-	column   string
-	operator string
-	value    string
-}
-
-func (e scalarExpression) ToPostgresWhereClause() (string, []any, error) {
-	return fmt.Sprintf(`"%s" %s ?`, e.column, e.operator), []any{e.value}, nil
-}
-
-func (c *Converter) parse(input []byte) (expression, error) {
-	raw := map[string]any{}
-	err := json.Unmarshal(input, &raw)
-	if err != nil {
-		return nil, fmt.Errorf("failed to unmarshal input: %w", err)
-	}
-	root := compoundExpression{
-		expressions: []expression{},
-		operator:    "AND",
-	}
-	for key, value := range raw {
-		expr := convertToExpression(key, value, key)
-		if expr == nil {
-			return nil, fmt.Errorf("failed to convert expression")
-		}
-		root.expressions = append(root.expressions, expr)
-	}
-
-	if root.operator != "AND" {
-		return nil, fmt.Errorf("root operator must be AND")
-	}
-	return root, nil
-}
-
-func convertToExpression(key string, value any, currentColumn string) expression {
-	switch value := value.(type) {
-	case int:
-	case int64:
-	case float64:
-	case string:
-		switch key {
-		case "$gt":
-			return &scalarExpression{
-				column:   currentColumn,
-				operator: ">",
-				value:    value,
-			}
-		case "$gte":
-			return &scalarExpression{
-				column:   currentColumn,
-				operator: ">=",
-				value:    value,
-			}
-		case "$lt":
-			return &scalarExpression{
-				column:   currentColumn,
-				operator: "<",
-				value:    value,
-			}
-		case "$lte":
-			return &scalarExpression{
-				column:   currentColumn,
-				operator: "<=",
-				value:    value,
-			}
-		case "$eq":
-			fallthrough
-		default:
-			return &scalarExpression{
-				column:   currentColumn,
-				operator: "=",
-				value:    value,
-			}
-		}
-	case map[string]any:
-		return convertToExpression(key, value, key)
-	}
-	return nil
-}
-*/