com.backnd.database 0.0.1

package/QueryBuilder.cs

@@ -0,0 +1,1001 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text;
+
+using BACKND.Database.Internal;
+using BACKND.Database.Network;
+
+using Newtonsoft.Json;
+
+using UnityEngine;
+
+namespace BACKND.Database
+{
+    public class QueryBuilder<T> where T : BaseModel, new()
+    {
+        private readonly Client client;
+        private readonly T modelInstance;
+
+        private readonly List<WhereCondition> whereConditions = new();
+        private readonly List<OrderByInfo> orderByList = new();
+        private readonly List<SetClause> setClauses = new();
+        private int? limit;
+        private int? offset;
+        private bool isOfCurrentUser;
+
+        internal QueryBuilder(Client client)
+        {
+            this.client = client;
+            this.modelInstance = new();
+        }
+
+        public QueryBuilder<T> Where(Expression<Func<T, bool>> predicate)
+        {
+            var condition = AnalyzeExpression(predicate);
+            if (condition != null)
+            {
+                whereConditions.Add(condition);
+            }
+            return this;
+        }
+
+        public QueryBuilder<T> OrderBy<TKey>(Expression<Func<T, TKey>> keySelector, bool descending = false)
+        {
+            var columnName = GetColumnNameFromExpression(keySelector);
+            if (!string.IsNullOrEmpty(columnName))
+            {
+                orderByList.Add(new()
+                {
+                    Column = columnName,
+                    Descending = descending
+                });
+            }
+            return this;
+        }
+
+        public QueryBuilder<T> OrderByDescending<TKey>(Expression<Func<T, TKey>> keySelector)
+        {
+            return OrderBy(keySelector, true);
+        }
+
+        public QueryBuilder<T> Take(int count)
+        {
+            limit = count;
+            return this;
+        }
+
+        public QueryBuilder<T> Skip(int count)
+        {
+            offset = count;
+            return this;
+        }
+
+        public QueryBuilder<T> OfCurrentUser()
+        {
+            isOfCurrentUser = true;
+            return this;
+        }
+
+        public async BTask<T> First()
+        {
+            var list = await Take(1).ToList();
+            if (list.Count == 0)
+                throw new InvalidOperationException("Sequence contains no elements");
+            return list[0];
+        }
+
+        public async BTask<T> FirstOrDefault()
+        {
+            var list = await Take(1).ToList();
+            return list.Count > 0 ? list[0] : null;
+        }
+
+        public async BTask<List<T>> ToList()
+        {
+            var query = BuildSelectQuery();
+            var parameters = GetQueryParameters();
+
+            var request = new DatabaseRequest
+            {
+                Query = query,
+                Parameters = parameters
+            };
+
+            var response = await client.ExecuteQuery(request);
+            return ParseResponse<T>(response);
+        }
+
+        public async BTask<int> Count()
+        {
+            var query = BuildCountQuery();
+            var parameters = GetQueryParameters();
+
+            var request = new DatabaseRequest
+            {
+                Query = query,
+                Parameters = parameters
+            };
+
+            var response = await client.ExecuteQuery(request);
+            return ParseCountResponse(response);
+        }
+
+        public async BTask<bool> Any()
+        {
+            return await Count() > 0;
+        }
+
+        public async BTask<InsertResult> Insert(T model)
+        {
+            ValidateModel(model);
+
+            var query = BuildInsertQuery(model, out var parameters);
+            var request = new DatabaseRequest { Query = query, Parameters = parameters };
+            var response = await client.ExecuteMutation(request);
+
+            if (!response.Success)
+                throw new Exception($"Insert failed: {response.Error}");
+
+            var result = JsonConvert.DeserializeObject<InsertResult>(response.Result);
+            if (result == null)
+                throw new Exception("Failed to parse insert result");
+
+            UpdateAutoIncrementId(model, result);
+
+            return result;
+        }
+
+        public async BTask<MutationResult> Update(T model)
+        {
+            ValidateModel(model);
+
+            // WHERE 절이 없으면 PrimaryKey로 자동 생성 시도
+            if (whereConditions.Count == 0)
+            {
+                var primaryKeyColumns = model.GetPrimaryKeyColumnNames();
+                if (primaryKeyColumns.Length == 0)
+                    throw new InvalidOperationException("Update requires a WHERE clause or a Primary Key");
+
+                // 복합 키 지원: 모든 PK 컬럼에 대해 WHERE 조건 생성
+                foreach (var primaryKeyColumn in primaryKeyColumns)
+                {
+                    var primaryKeyValue = model.GetValue(primaryKeyColumn);
+                    if (primaryKeyValue == null)
+                        throw new InvalidOperationException($"Primary Key '{primaryKeyColumn}' has no value. Either set the Primary Key or provide a WHERE clause");
+
+                    whereConditions.Add(new WhereCondition
+                    {
+                        ColumnName = primaryKeyColumn,
+                        Operator = CompareOperator.Equal,
+                        Value = primaryKeyValue,
+                        LogicalOperator = LogicalOperator.And
+                    });
+                }
+            }
+
+            var whereClause = BuildWhereClause();
+            var query = BuildUpdateQuery(model, whereClause, out var parameters);
+
+            foreach (var param in GetQueryParameters())
+                parameters[param.Key] = param.Value;
+
+            var request = new DatabaseRequest { Query = query, Parameters = parameters };
+            var response = await client.ExecuteMutation(request);
+
+            if (!response.Success)
+                throw new Exception($"Update failed: {response.Error}");
+
+            var result = JsonConvert.DeserializeObject<MutationResult>(response.Result);
+            if (result == null)
+                throw new Exception("Failed to parse update result");
+
+            return result;
+        }
+
+        public async BTask<MutationResult> Delete()
+        {
+            if (whereConditions.Count == 0)
+                throw new InvalidOperationException("Delete requires a WHERE clause");
+
+            var whereClause = BuildWhereClause();
+            var query = BuildDeleteQuery(whereClause);
+            var parameters = GetQueryParameters();
+
+            var request = new DatabaseRequest { Query = query, Parameters = parameters };
+            var response = await client.ExecuteMutation(request);
+
+            if (!response.Success)
+                throw new Exception($"Delete failed: {response.Error}");
+
+            var result = JsonConvert.DeserializeObject<MutationResult>(response.Result);
+            if (result == null)
+                throw new Exception("Failed to parse delete result");
+
+            return result;
+        }
+
+        public QueryBuilder<T> Inc<TField>(Expression<Func<T, TField>> selector, TField value)
+        {
+            var columnName = GetColumnNameFromExpression(selector);
+            ValidateNoDuplicateSetClause(columnName);
+            setClauses.Add(new SetClause
+            {
+                ColumnName = columnName,
+                Operator = "+",
+                Value = value
+            });
+            return this;
+        }
+
+        public QueryBuilder<T> Dec<TField>(Expression<Func<T, TField>> selector, TField value)
+        {
+            var columnName = GetColumnNameFromExpression(selector);
+            ValidateNoDuplicateSetClause(columnName);
+            setClauses.Add(new SetClause
+            {
+                ColumnName = columnName,
+                Operator = "-",
+                Value = value
+            });
+            return this;
+        }
+
+        private void ValidateNoDuplicateSetClause(string columnName)
+        {
+            if (setClauses.Any(c => c.ColumnName == columnName))
+                throw new InvalidOperationException($"'{columnName}' is already being modified. Each field can only be modified once.");
+        }
+
+        public async BTask<MutationResult> Exec()
+        {
+            if (setClauses.Count == 0)
+                throw new InvalidOperationException("No modifications specified. Use Inc() or Dec() before Exec()");
+
+            if (whereConditions.Count == 0)
+                throw new InvalidOperationException("Exec requires a Where() condition");
+
+            var whereClause = BuildWhereClause();
+            var query = BuildUpdateQueryFromSetClauses(whereClause);
+            var parameters = GetQueryParameters();
+
+            var request = new DatabaseRequest { Query = query, Parameters = parameters };
+            var response = await client.ExecuteMutation(request);
+
+            if (!response.Success)
+                throw new Exception($"Update failed: {response.Error}");
+
+            var result = JsonConvert.DeserializeObject<MutationResult>(response.Result);
+            if (result == null)
+                throw new Exception("Failed to parse update result");
+
+            return result;
+        }
+
+        private string BuildUpdateQueryFromSetClauses(string whereClause)
+        {
+            var setStatements = setClauses.Select(clause =>
+                $"{clause.ColumnName} = {clause.ColumnName} {clause.Operator} {FormatValueForQuery(clause.Value)}"
+            );
+
+            return $"UPDATE {modelInstance.GetTableName()} SET {string.Join(", ", setStatements)} WHERE {whereClause}";
+        }
+
+        private WhereCondition AnalyzeExpression(Expression<Func<T, bool>> expression)
+        {
+            try
+            {
+                var result = AnalyzeBinaryExpression(expression.Body);
+                if (result == null && Application.platform == RuntimePlatform.WebGLPlayer)
+                {
+                    Debug.LogWarning("Complex expression analysis failed. Consider using simpler conditions or multiple Where() calls.");
+                }
+
+                return result;
+            }
+            catch (Exception ex)
+            {
+                Debug.LogWarning($"Expression analysis failed: {ex.Message}. " +
+                    $"Platform: {Application.platform}. " +
+                    "Falling back to runtime evaluation may not work. " +
+                    "Consider using multiple Where() calls instead.");
+                return null;
+            }
+        }
+
+        private WhereCondition AnalyzeBinaryExpression(Expression expression)
+        {
+            if (expression is BinaryExpression binaryExpr)
+            {
+                if (binaryExpr.NodeType == ExpressionType.AndAlso || binaryExpr.NodeType == ExpressionType.OrElse)
+                {
+                    var leftCondition = AnalyzeBinaryExpression(binaryExpr.Left);
+                    var rightCondition = AnalyzeBinaryExpression(binaryExpr.Right);
+
+                    if (leftCondition != null && rightCondition != null)
+                    {
+                        if (binaryExpr.NodeType == ExpressionType.OrElse)
+                        {
+                            rightCondition.LogicalOperator = LogicalOperator.Or;
+                        }
+
+                        whereConditions.Add(leftCondition);
+                        return rightCondition;
+                    }
+                }
+
+                if (IsComparisonOperator(binaryExpr.NodeType))
+                {
+                    var columnName = GetColumnNameFromMemberExpression(binaryExpr.Left);
+                    var value = GetConstantValue(binaryExpr.Right);
+                    var op = GetCompareOperator(binaryExpr.NodeType);
+
+                    return new()
+                    {
+                        ColumnName = columnName,
+                        Operator = op,
+                        Value = value,
+                        LogicalOperator = LogicalOperator.And
+                    };
+                }
+
+                throw new NotSupportedException($"Binary operator {binaryExpr.NodeType} not yet supported");
+            }
+
+            if (expression is MethodCallExpression methodCall)
+            {
+                return AnalyzeMethodCall(methodCall);
+            }
+
+            if (expression is UnaryExpression unaryExpr)
+            {
+                if (unaryExpr.NodeType == ExpressionType.Not)
+                {
+                    var innerCondition = AnalyzeBinaryExpression(unaryExpr.Operand);
+                    if (innerCondition != null)
+                    {
+                        innerCondition.Operator = GetNegatedOperator(innerCondition.Operator);
+                        return innerCondition;
+                    }
+                }
+            }
+
+            throw new NotSupportedException($"Expression type {expression.NodeType} is not supported");
+        }
+
+        private WhereCondition AnalyzeMethodCall(MethodCallExpression methodCall)
+        {
+            if (methodCall.Method.Name == "Contains" && methodCall.Method.DeclaringType == typeof(string))
+            {
+                throw new NotSupportedException("String.Contains is not supported because server doesn't support LIKE operator. Use exact equality comparison instead.");
+            }
+
+            if (methodCall.Method.Name == "Contains" && methodCall.Object != null)
+            {
+                var columnName = GetColumnNameFromMemberExpression(methodCall.Arguments[0]);
+                var values = GetConstantValue(methodCall.Object);
+
+                return new()
+                {
+                    ColumnName = columnName,
+                    Operator = CompareOperator.In,
+                    Value = values,
+                    LogicalOperator = LogicalOperator.And
+                };
+            }
+
+            throw new NotSupportedException($"Method {methodCall.Method.Name} is not supported");
+        }
+
+        private string GetColumnNameFromMemberExpression(Expression expression)
+        {
+            if (expression is MemberExpression memberExpr && memberExpr.Expression?.NodeType == ExpressionType.Parameter)
+            {
+                if (modelInstance is BaseModel baseModel)
+                {
+                    return baseModel.GetColumnName(memberExpr.Member.Name);
+                }
+            }
+
+            throw new NotSupportedException("Only simple property access is supported (e.g., x => x.PropertyName)");
+        }
+
+        private string GetColumnNameFromExpression<TKey>(Expression<Func<T, TKey>> keySelector)
+        {
+            return GetColumnNameFromMemberExpression(keySelector.Body);
+        }
+
+        private object GetConstantValue(Expression expression)
+        {
+            if (expression is ConstantExpression constantExpr)
+            {
+                return constantExpr.Value;
+            }
+
+            if (expression is MemberExpression memberExpr)
+            {
+                if (memberExpr.Expression is ConstantExpression containerExpr)
+                {
+                    var container = containerExpr.Value;
+                    if (container == null) return null;
+
+                    if (memberExpr.Member is System.Reflection.FieldInfo field)
+                    {
+                        return field.GetValue(container);
+                    }
+                    if (memberExpr.Member is System.Reflection.PropertyInfo property)
+                    {
+                        return property.GetValue(container);
+                    }
+                }
+
+                if (memberExpr.Expression == null && memberExpr.Member is System.Reflection.FieldInfo staticField)
+                {
+                    return staticField.GetValue(null);
+                }
+                if (memberExpr.Expression == null && memberExpr.Member is System.Reflection.PropertyInfo staticProperty)
+                {
+                    return staticProperty.GetValue(null);
+                }
+
+                if (memberExpr.Expression is MemberExpression nestedMember)
+                {
+                    var parentValue = GetConstantValue(nestedMember);
+                    if (parentValue == null) return null;
+
+                    if (memberExpr.Member is System.Reflection.FieldInfo field)
+                    {
+                        return field.GetValue(parentValue);
+                    }
+                    if (memberExpr.Member is System.Reflection.PropertyInfo property)
+                    {
+                        return property.GetValue(parentValue);
+                    }
+                }
+            }
+
+            if (expression is UnaryExpression unaryExpr)
+            {
+                if (unaryExpr.NodeType == ExpressionType.Convert || unaryExpr.NodeType == ExpressionType.ConvertChecked)
+                {
+                    var innerValue = GetConstantValue(unaryExpr.Operand);
+                    if (innerValue != null && innerValue.GetType().IsEnum)
+                    {
+                        return Convert.ToInt32(innerValue);
+                    }
+                    return innerValue;
+                }
+
+                if (unaryExpr.NodeType == ExpressionType.Quote)
+                {
+                    return GetConstantValue(unaryExpr.Operand);
+                }
+            }
+
+            if (expression is MethodCallExpression methodCallExpr)
+            {
+                try
+                {
+                    if (methodCallExpr.Object == null)
+                    {
+                        var args = methodCallExpr.Arguments.Select(GetConstantValue).ToArray();
+                        return methodCallExpr.Method.Invoke(null, args);
+                    }
+
+                    var instance = GetConstantValue(methodCallExpr.Object);
+                    if (instance != null)
+                    {
+                        var args = methodCallExpr.Arguments.Select(GetConstantValue).ToArray();
+                        return methodCallExpr.Method.Invoke(instance, args);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    throw new NotSupportedException(
+                        $"Method call {methodCallExpr.Method.Name} cannot be evaluated at compile time. " +
+                        $"Platform: {Application.platform}. Use local variables instead.", ex);
+                }
+            }
+
+            if (expression is NewExpression newExpr)
+            {
+                try
+                {
+                    var args = newExpr.Arguments.Select(GetConstantValue).ToArray();
+                    return Activator.CreateInstance(newExpr.Type, args);
+                }
+                catch (Exception ex)
+                {
+                    throw new NotSupportedException(
+                        $"Cannot create instance of {newExpr.Type.Name} on platform {Application.platform}. " +
+                        "Use local variables instead.", ex);
+                }
+            }
+
+            if (expression is ConditionalExpression conditionalExpr)
+            {
+                var testValue = GetConstantValue(conditionalExpr.Test);
+                if (testValue is bool testBool)
+                {
+                    return testBool
+                        ? GetConstantValue(conditionalExpr.IfTrue)
+                        : GetConstantValue(conditionalExpr.IfFalse);
+                }
+            }
+
+            if (expression is BinaryExpression binaryExpr && !IsComparisonOperator(binaryExpr.NodeType))
+            {
+                var left = GetConstantValue(binaryExpr.Left);
+                var right = GetConstantValue(binaryExpr.Right);
+
+                return binaryExpr.NodeType switch
+                {
+                    ExpressionType.Add => ExpressionAnalyzer.AddValues(left, right),
+                    ExpressionType.Subtract => ExpressionAnalyzer.SubtractValues(left, right),
+                    ExpressionType.Multiply => ExpressionAnalyzer.MultiplyValues(left, right),
+                    ExpressionType.Divide => ExpressionAnalyzer.DivideValues(left, right),
+                    ExpressionType.Modulo => ExpressionAnalyzer.ModuloValues(left, right),
+                    ExpressionType.Coalesce => left ?? right,
+                    _ => throw new NotSupportedException($"Binary operator {binaryExpr.NodeType} not supported in constant evaluation")
+                };
+            }
+
+            throw new NotSupportedException(
+                $"Expression {expression.NodeType} cannot be evaluated at compile time. " +
+                "Use local variables: var id = 5; Where(x => x.Id == id)");
+        }
+
+        private string BuildSelectQuery()
+        {
+            var sb = new StringBuilder();
+            sb.Append("SELECT ");
+            sb.Append(modelInstance.GetColumnList());
+            sb.Append($" FROM {modelInstance.GetTableName()}");
+
+            var whereClause = BuildWhereClause();
+            if (!string.IsNullOrEmpty(whereClause))
+                sb.Append($" WHERE {whereClause}");
+
+            var orderByClause = BuildOrderByClause();
+            if (!string.IsNullOrEmpty(orderByClause))
+                sb.Append($" ORDER BY {orderByClause}");
+
+            if (limit.HasValue)
+                sb.Append($" LIMIT {limit.Value}");
+
+            if (offset.HasValue)
+                sb.Append($" OFFSET {offset.Value}");
+
+            return sb.ToString();
+        }
+
+        private string BuildCountQuery()
+        {
+            var sb = new StringBuilder();
+            sb.Append($"SELECT COUNT(1) FROM {modelInstance.GetTableName()}");
+
+            var whereClause = BuildWhereClause();
+            if (!string.IsNullOrEmpty(whereClause))
+                sb.Append($" WHERE {whereClause}");
+
+            return sb.ToString();
+        }
+
+        private string BuildWhereClause()
+        {
+            if (whereConditions.Count == 0 && !isOfCurrentUser)
+                return null;
+
+            var sb = new StringBuilder();
+
+            var hasUserUuidCondition = whereConditions.Any(c => c.ColumnName == "user_uuid");
+            if (isOfCurrentUser && modelInstance.GetTableType() == TableType.UserTable && !hasUserUuidCondition)
+            {
+                sb.Append("user_uuid = @current_user_uuid");
+                if (whereConditions.Count > 0)
+                    sb.Append(" AND ");
+            }
+
+            for (int i = 0; i < whereConditions.Count; i++)
+            {
+                var condition = whereConditions[i];
+
+                if (condition.IsGroupStart)
+                {
+                    sb.Append("(");
+                }
+
+                if (i > 0 && !condition.IsGroupStart)
+                {
+                    sb.Append(condition.LogicalOperator == LogicalOperator.And ? " AND " : " OR ");
+                }
+
+                sb.Append(BuildConditionString(condition));
+
+                if (condition.IsGroupEnd)
+                {
+                    sb.Append(")");
+                }
+            }
+
+            return sb.ToString();
+        }
+
+        private string BuildConditionString(WhereCondition condition)
+        {
+            // NULL 비교 시 자동으로 IS NULL / IS NOT NULL로 변환
+            if (condition.Value == null)
+            {
+                return condition.Operator switch
+                {
+                    CompareOperator.Equal => $"{condition.ColumnName} IS NULL",
+                    CompareOperator.NotEqual => $"{condition.ColumnName} IS NOT NULL",
+                    CompareOperator.IsNull => $"{condition.ColumnName} IS NULL",
+                    CompareOperator.IsNotNull => $"{condition.ColumnName} IS NOT NULL",
+                    _ => throw new NotSupportedException($"NULL comparison with operator {condition.Operator} is not supported. Use 'IS NULL' or 'IS NOT NULL'")
+                };
+            }
+
+            return condition.Operator switch
+            {
+                CompareOperator.Equal => $"{condition.ColumnName} = {FormatValueForQuery(condition.Value)}",
+                CompareOperator.NotEqual => $"{condition.ColumnName} != {FormatValueForQuery(condition.Value)}",
+                CompareOperator.GreaterThan => $"{condition.ColumnName} > {FormatValueForQuery(condition.Value)}",
+                CompareOperator.GreaterThanOrEqual => $"{condition.ColumnName} >= {FormatValueForQuery(condition.Value)}",
+                CompareOperator.LessThan => $"{condition.ColumnName} < {FormatValueForQuery(condition.Value)}",
+                CompareOperator.LessThanOrEqual => $"{condition.ColumnName} <= {FormatValueForQuery(condition.Value)}",
+                CompareOperator.Between => $"{condition.ColumnName} BETWEEN {FormatValueForQuery(condition.Value)} AND {FormatValueForQuery(condition.SecondValue)}",
+                CompareOperator.In => BuildInClause(condition),
+                CompareOperator.IsNull => $"{condition.ColumnName} IS NULL",
+                CompareOperator.IsNotNull => $"{condition.ColumnName} IS NOT NULL",
+                _ => throw new NotSupportedException($"Operator {condition.Operator} is not supported")
+            };
+        }
+
+        private string BuildInClause(WhereCondition condition)
+        {
+            if (condition.Value is Array array)
+            {
+                var values = new List<string>();
+                foreach (var item in array)
+                {
+                    values.Add(FormatValueForQuery(item));
+                }
+                return $"{condition.ColumnName} IN ({string.Join(", ", values)})";
+            }
+
+            return $"{condition.ColumnName} = {FormatValueForQuery(condition.Value)}";
+        }
+
+        private string BuildOrderByClause()
+        {
+            if (orderByList.Count == 0)
+                return null;
+
+            var clauses = orderByList.Select(o => $"{o.Column} {(o.Descending ? "DESC" : "ASC")}");
+            return string.Join(", ", clauses);
+        }
+
+        private bool IsComparisonOperator(ExpressionType nodeType)
+        {
+            return nodeType == ExpressionType.Equal ||
+                   nodeType == ExpressionType.NotEqual ||
+                   nodeType == ExpressionType.GreaterThan ||
+                   nodeType == ExpressionType.GreaterThanOrEqual ||
+                   nodeType == ExpressionType.LessThan ||
+                   nodeType == ExpressionType.LessThanOrEqual;
+        }
+
+        private CompareOperator GetCompareOperator(ExpressionType nodeType)
+        {
+            return nodeType switch
+            {
+                ExpressionType.Equal => CompareOperator.Equal,
+                ExpressionType.NotEqual => CompareOperator.NotEqual,
+                ExpressionType.GreaterThan => CompareOperator.GreaterThan,
+                ExpressionType.GreaterThanOrEqual => CompareOperator.GreaterThanOrEqual,
+                ExpressionType.LessThan => CompareOperator.LessThan,
+                ExpressionType.LessThanOrEqual => CompareOperator.LessThanOrEqual,
+                _ => throw new NotSupportedException($"Operation {nodeType} is not supported")
+            };
+        }
+
+        private CompareOperator GetNegatedOperator(CompareOperator originalOperator)
+        {
+            return originalOperator switch
+            {
+                CompareOperator.Equal => CompareOperator.NotEqual,
+                CompareOperator.NotEqual => CompareOperator.Equal,
+                CompareOperator.GreaterThan => CompareOperator.LessThanOrEqual,
+                CompareOperator.GreaterThanOrEqual => CompareOperator.LessThan,
+                CompareOperator.LessThan => CompareOperator.GreaterThanOrEqual,
+                CompareOperator.LessThanOrEqual => CompareOperator.GreaterThan,
+                CompareOperator.IsNull => CompareOperator.IsNotNull,
+                CompareOperator.IsNotNull => CompareOperator.IsNull,
+                _ => throw new NotSupportedException($"Cannot negate operator {originalOperator}")
+            };
+        }
+
+
+        private static readonly HashSet<string> SqlFunctionsAndKeywords = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+        {
+            "NOW()", "CURRENT_TIMESTAMP", "CURRENT_TIMESTAMP()", "UUID()",
+            "CURRENT_DATE", "CURRENT_DATE()", "CURRENT_TIME", "CURRENT_TIME()",
+            "NULL"
+        };
+
+        private static bool IsSqlFunctionOrKeyword(string value)
+        {
+            if (string.IsNullOrWhiteSpace(value)) return false;
+            return SqlFunctionsAndKeywords.Contains(value.Trim());
+        }
+
+        private static string FormatValueForQuery(object value)
+        {
+            if (value == null) return "NULL";
+
+            // 값을 문자열로 변환
+            var stringValue = ConvertValueToString(value);
+
+            // SQL 함수 및 키워드는 따옴표 없이 그대로 반환
+            if (IsSqlFunctionOrKeyword(stringValue))
+            {
+                return stringValue.Trim();
+            }
+
+            // 길이 제한 검사
+            const int maxLength = 1024 * 12; // 12KB
+            if (stringValue.Length > maxLength)
+            {
+                throw new ArgumentException($"Value too long. Maximum length is {maxLength} characters, but got {stringValue.Length}");
+            }
+
+            // 함수와 NULL을 제외한 모든 값은 따옴표로 감싸기
+            return $"'{stringValue.Replace("'", "''").Replace("\\", "\\\\")}'";
+        }
+
+        private static string ConvertValueToString(object value)
+        {
+            if (value == null) return "NULL";
+
+            var valueType = value.GetType();
+
+            // DateTime → ISO 8601 포맷
+            if (valueType == typeof(DateTime))
+                return ((DateTime)value).ToString("yyyy-MM-ddTHH:mm:ss.fffZ");
+
+            // bool → 소문자
+            if (valueType == typeof(bool))
+                return ((bool)value) ? "true" : "false";
+
+            // Enum → 숫자
+            if (valueType.IsEnum)
+                return ((int)value).ToString();
+
+            // 복합 객체 → JSON
+            if (!valueType.IsPrimitive && valueType != typeof(string) && valueType != typeof(Guid))
+            {
+                try
+                {
+                    return JsonConvert.SerializeObject(value, new JsonSerializerSettings
+                    {
+                        ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
+                        NullValueHandling = NullValueHandling.Ignore,
+                        DefaultValueHandling = DefaultValueHandling.Ignore,
+                        Formatting = Formatting.None
+                    });
+                }
+                catch (JsonException ex)
+                {
+                    throw new InvalidOperationException($"Failed to serialize object of type {valueType.Name} to JSON", ex);
+                }
+            }
+
+            // 기본: ToString()
+            return value.ToString();
+        }
+
+        private Dictionary<string, object> GetQueryParameters()
+        {
+            var parameters = new Dictionary<string, object>();
+
+            if (isOfCurrentUser && modelInstance.GetTableType() == TableType.UserTable && client.UserUUID != null)
+            {
+                parameters["@current_user_uuid"] = client.UserUUID;
+            }
+
+            return parameters;
+        }
+
+        private void ValidateModel(T model)
+        {
+            if (model == null)
+                throw new ArgumentNullException(nameof(model));
+        }
+
+        private string BuildInsertQuery(T model, out Dictionary<string, object> parameters)
+        {
+            parameters = new();
+            var columns = new List<string>();
+            var values = new List<string>();
+
+            var columnList = modelInstance.GetColumnList().Split(',').Select(c => c.Trim()).ToArray();
+            var autoIncrementColumn = model.GetAutoIncrementColumnName();
+
+            foreach (var columnName in columnList)
+            {
+                // AutoIncrement 컬럼은 INSERT에서 제외
+                if (!string.IsNullOrEmpty(autoIncrementColumn) &&
+                    autoIncrementColumn.Equals(columnName, StringComparison.OrdinalIgnoreCase))
+                    continue;
+
+                var value = model.GetValue(columnName);
+                var isNullableType = model.IsPropertyNullableType(columnName);
+                var isColumnNullable = model.IsColumnNullable(columnName);
+
+                // Nullable<T> 타입(int?, DateTime? 등)이고 값이 null인 경우
+                if (isNullableType && value == null)
+                {
+                    if (isColumnNullable)
+                    {
+                        // NULL 허용 컬럼이면 NULL 값으로 INSERT
+                        columns.Add(columnName);
+                        values.Add("NULL");
+                        continue;
+                    }
+                    else
+                    {
+                        // NotNull 컬럼인데 값이 null이면 기본값 확인
+                        var defaultValue = model.GetColumnDefaultValue(columnName);
+                        if (!string.IsNullOrEmpty(defaultValue))
+                            continue;
+
+                        throw new InvalidOperationException($"Column '{columnName}' cannot be null");
+                    }
+                }
+
+                // 참조 타입(string, class 등)이 null인 경우
+                if (!isColumnNullable && value == null)
+                {
+                    var defaultValue = model.GetColumnDefaultValue(columnName);
+                    if (!string.IsNullOrEmpty(defaultValue))
+                        continue;
+
+                    throw new InvalidOperationException($"Column '{columnName}' cannot be null");
+                }
+
+                columns.Add(columnName);
+                values.Add(FormatValueForQuery(value));
+            }
+
+            if (columns.Count == 0)
+                throw new InvalidOperationException("No columns to insert");
+
+            return $"INSERT INTO {modelInstance.GetTableName()} ({string.Join(", ", columns)}) VALUES ({string.Join(", ", values)})";
+        }
+
+        private string BuildUpdateQuery(T model, string whereClause, out Dictionary<string, object> parameters)
+        {
+            parameters = new();
+            var setClauses = new List<string>();
+
+            var columnList = modelInstance.GetColumnList().Split(',').Select(c => c.Trim()).ToArray();
+            var primaryKeyColumns = model.GetPrimaryKeyColumnNames();
+
+            foreach (var columnName in columnList)
+            {
+                // PK 컬럼은 UPDATE SET 절에서 제외
+                if (primaryKeyColumns.Any(pk => pk.Equals(columnName, StringComparison.OrdinalIgnoreCase)))
+                    continue;
+
+                var value = model.GetValue(columnName);
+                var isNullableType = model.IsPropertyNullableType(columnName);
+                var isColumnNullable = model.IsColumnNullable(columnName);
+
+                // Nullable<T> 타입(int?, DateTime? 등)이고 값이 null인 경우
+                if (isNullableType && value == null)
+                {
+                    if (isColumnNullable)
+                    {
+                        // NULL 허용 컬럼이면 NULL로 UPDATE
+                        setClauses.Add($"{columnName} = NULL");
+                        continue;
+                    }
+                    else
+                    {
+                        throw new InvalidOperationException($"Column '{columnName}' cannot be null");
+                    }
+                }
+
+                // 참조 타입(string, class 등)이 null인 경우
+                if (!isColumnNullable && value == null)
+                    throw new InvalidOperationException($"Column '{columnName}' cannot be null");
+
+                setClauses.Add($"{columnName} = {FormatValueForQuery(value)}");
+            }
+
+            if (setClauses.Count == 0)
+                throw new InvalidOperationException("No columns to update");
+
+            return $"UPDATE {modelInstance.GetTableName()} SET {string.Join(", ", setClauses)} WHERE {whereClause}";
+        }
+
+        private string BuildDeleteQuery(string whereClause)
+        {
+            return $"DELETE FROM {modelInstance.GetTableName()} WHERE {whereClause}";
+        }
+
+        private void UpdateAutoIncrementId(T model, InsertResult result)
+        {
+            var autoIncrementColumn = model.GetAutoIncrementColumnName();
+            if (string.IsNullOrEmpty(autoIncrementColumn))
+                return;
+
+            try
+            {
+                if (result?.LastInsertId != null)
+                {
+                    model.SetValue(autoIncrementColumn, result.LastInsertId);
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.LogWarning($"Failed to update auto-increment ID: {ex.Message}");
+            }
+        }
+
+        private List<TModel> ParseResponse<TModel>(Response response) where TModel : BaseModel, new()
+        {
+            if (!response.Success)
+                throw new Exception($"Query failed: {response.Error}");
+
+            var result = JsonConvert.DeserializeObject<QueryResult>(response.Result);
+            if (result?.Data == null) return new List<TModel>();
+
+            var list = new List<TModel>();
+            foreach (var row in result.Data)
+            {
+                try
+                {
+                    var model = new TModel();
+                    foreach (var kvp in row)
+                    {
+                        try
+                        {
+                            model.SetValue(kvp.Key, kvp.Value);
+                        }
+                        catch (Exception ex)
+                        {
+                            Debug.LogWarning($"Failed to set value for column '{kvp.Key}', value: '{kvp.Value}'. Error: {ex.Message}");
+                        }
+                    }
+                    list.Add(model);
+                }
+                catch (Exception ex)
+                {
+                    Debug.LogError($"Row parsing failed: {ex.Message}");
+                }
+            }
+            return list;
+        }
+
+        private int ParseCountResponse(Response response)
+        {
+            if (!response.Success)
+                throw new Exception($"Query failed: {response.Error}");
+
+            var result = JsonConvert.DeserializeObject<QueryResult>(response.Result);
+            if (result?.Data != null && result.Data.Count > 0)
+            {
+                var firstRow = result.Data[0];
+                if (firstRow.ContainsKey("count(1)"))
+                    return Convert.ToInt32(firstRow["count(1)"]);
+                if (firstRow.ContainsKey("COUNT(1)"))
+                    return Convert.ToInt32(firstRow["COUNT(1)"]);
+            }
+
+            return 0;
+        }
+    }
+}