com.backnd.database 0.0.1

package/Internal/SqlBuilder.cs

@@ -0,0 +1,375 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace BACKND.Database.Internal
+{
+    /// <summary>
+    /// SQL 쿼리 생성 유틸리티
+    /// </summary>
+    public static class SqlBuilder
+    {
+        #region WHERE 절 생성
+
+        /// <summary>
+        /// WhereCondition 목록에서 WHERE 절 생성
+        /// </summary>
+        public static string BuildWhereClause(
+            List<WhereCondition> whereConditions,
+            bool isOfCurrentUser = false,
+            TableType? tableType = null)
+        {
+            if (whereConditions.Count == 0 && !isOfCurrentUser)
+                return null;
+
+            var sb = new StringBuilder();
+
+            var hasUserUuidCondition = whereConditions.Any(c => c.ColumnName == "user_uuid");
+            if (isOfCurrentUser && tableType == 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();
+        }
+
+        /// <summary>
+        /// 단일 WhereCondition을 SQL 조건 문자열로 변환
+        /// </summary>
+        public static 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} = {ValueFormatter.FormatValueForQuery(condition.Value)}",
+                CompareOperator.NotEqual => $"{condition.ColumnName} != {ValueFormatter.FormatValueForQuery(condition.Value)}",
+                CompareOperator.GreaterThan => $"{condition.ColumnName} > {ValueFormatter.FormatValueForQuery(condition.Value)}",
+                CompareOperator.GreaterThanOrEqual => $"{condition.ColumnName} >= {ValueFormatter.FormatValueForQuery(condition.Value)}",
+                CompareOperator.LessThan => $"{condition.ColumnName} < {ValueFormatter.FormatValueForQuery(condition.Value)}",
+                CompareOperator.LessThanOrEqual => $"{condition.ColumnName} <= {ValueFormatter.FormatValueForQuery(condition.Value)}",
+                CompareOperator.Between => $"{condition.ColumnName} BETWEEN {ValueFormatter.FormatValueForQuery(condition.Value)} AND {ValueFormatter.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")
+            };
+        }
+
+        /// <summary>
+        /// IN 절 생성
+        /// </summary>
+        public static string BuildInClause(WhereCondition condition)
+        {
+            if (condition.Value is Array array)
+            {
+                var values = new List<string>();
+                foreach (var item in array)
+                {
+                    values.Add(ValueFormatter.FormatValueForQuery(item));
+                }
+                return $"{condition.ColumnName} IN ({string.Join(", ", values)})";
+            }
+
+            return $"{condition.ColumnName} = {ValueFormatter.FormatValueForQuery(condition.Value)}";
+        }
+
+        #endregion
+
+        #region ORDER BY 절 생성
+
+        /// <summary>
+        /// OrderByInfo 목록에서 ORDER BY 절 생성
+        /// </summary>
+        public static string BuildOrderByClause(List<OrderByInfo> orderByList)
+        {
+            if (orderByList == null || orderByList.Count == 0)
+                return null;
+
+            var clauses = orderByList.Select(o => $"{o.Column} {(o.Descending ? "DESC" : "ASC")}");
+            return string.Join(", ", clauses);
+        }
+
+        #endregion
+
+        #region INSERT 쿼리 생성
+
+        /// <summary>
+        /// INSERT 쿼리 생성
+        /// </summary>
+        public static string BuildInsertQuery(BaseModel model, out Dictionary<string, object> parameters)
+        {
+            parameters = new Dictionary<string, object>();
+            var columns = new List<string>();
+            var values = new List<string>();
+
+            var tableName = model.GetTableName();
+            var columnList = model.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(ValueFormatter.FormatValueForQuery(value));
+            }
+
+            if (columns.Count == 0)
+                throw new InvalidOperationException("No columns to insert");
+
+            return $"INSERT INTO {tableName} ({string.Join(", ", columns)}) VALUES ({string.Join(", ", values)})";
+        }
+
+        #endregion
+
+        #region UPDATE 쿼리 생성
+
+        /// <summary>
+        /// 모델 기반 UPDATE 쿼리 생성
+        /// </summary>
+        public static string BuildUpdateQuery(BaseModel model, string whereClause, out Dictionary<string, object> parameters)
+        {
+            parameters = new Dictionary<string, object>();
+            var setClauses = new List<string>();
+
+            var tableName = model.GetTableName();
+            var columnList = model.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} = {ValueFormatter.FormatValueForQuery(value)}");
+            }
+
+            if (setClauses.Count == 0)
+                throw new InvalidOperationException("No columns to update");
+
+            return $"UPDATE {tableName} SET {string.Join(", ", setClauses)} WHERE {whereClause}";
+        }
+
+        /// <summary>
+        /// SetClause 목록 기반 UPDATE 쿼리 생성 (Inc/Dec용)
+        /// </summary>
+        public static string BuildUpdateQueryFromSetClauses(string tableName, List<SetClause> setClauses, string whereClause)
+        {
+            if (setClauses == null || setClauses.Count == 0)
+                throw new InvalidOperationException("No set clauses specified");
+
+            var setStatements = setClauses.Select(clause =>
+                $"{clause.ColumnName} = {clause.ColumnName} {clause.Operator} {ValueFormatter.FormatValueForQuery(clause.Value)}"
+            );
+
+            return $"UPDATE {tableName} SET {string.Join(", ", setStatements)} WHERE {whereClause}";
+        }
+
+        #endregion
+
+        #region DELETE 쿼리 생성
+
+        /// <summary>
+        /// DELETE 쿼리 생성
+        /// </summary>
+        public static string BuildDeleteQuery(string tableName, string whereClause)
+        {
+            if (string.IsNullOrEmpty(whereClause))
+                throw new InvalidOperationException("DELETE requires a WHERE clause");
+
+            return $"DELETE FROM {tableName} WHERE {whereClause}";
+        }
+
+        #endregion
+
+        #region SELECT 쿼리 생성
+
+        /// <summary>
+        /// SELECT 쿼리 생성
+        /// </summary>
+        public static string BuildSelectQuery(
+            string tableName,
+            string columnList,
+            List<WhereCondition> whereConditions,
+            List<OrderByInfo> orderByList,
+            int? limit = null,
+            int? offset = null,
+            bool isOfCurrentUser = false,
+            TableType? tableType = null)
+        {
+            var sb = new StringBuilder();
+            sb.Append("SELECT ");
+            sb.Append(columnList);
+            sb.Append($" FROM {tableName}");
+
+            var whereClause = BuildWhereClause(whereConditions, isOfCurrentUser, tableType);
+            if (!string.IsNullOrEmpty(whereClause))
+                sb.Append($" WHERE {whereClause}");
+
+            var orderByClause = BuildOrderByClause(orderByList);
+            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();
+        }
+
+        /// <summary>
+        /// COUNT 쿼리 생성
+        /// </summary>
+        public static string BuildCountQuery(
+            string tableName,
+            List<WhereCondition> whereConditions,
+            bool isOfCurrentUser = false,
+            TableType? tableType = null)
+        {
+            var sb = new StringBuilder();
+            sb.Append($"SELECT COUNT(1) FROM {tableName}");
+
+            var whereClause = BuildWhereClause(whereConditions, isOfCurrentUser, tableType);
+            if (!string.IsNullOrEmpty(whereClause))
+                sb.Append($" WHERE {whereClause}");
+
+            return sb.ToString();
+        }
+
+        #endregion
+
+        #region Primary Key WHERE 절 생성
+
+        /// <summary>
+        /// 모델의 Primary Key로 WHERE 조건 목록 생성
+        /// </summary>
+        public static List<WhereCondition> BuildPrimaryKeyConditions(BaseModel model)
+        {
+            var conditions = new List<WhereCondition>();
+            var primaryKeyColumns = model.GetPrimaryKeyColumnNames();
+
+            if (primaryKeyColumns.Length == 0)
+                throw new InvalidOperationException("Model has no Primary Key defined");
+
+            foreach (var primaryKeyColumn in primaryKeyColumns)
+            {
+                var primaryKeyValue = model.GetValue(primaryKeyColumn);
+                if (primaryKeyValue == null)
+                    throw new InvalidOperationException($"Primary Key '{primaryKeyColumn}' has no value");
+
+                conditions.Add(new WhereCondition
+                {
+                    ColumnName = primaryKeyColumn,
+                    Operator = CompareOperator.Equal,
+                    Value = primaryKeyValue,
+                    LogicalOperator = LogicalOperator.And
+                });
+            }
+
+            return conditions;
+        }
+
+        #endregion
+    }
+}

package/Internal/SqlBuilder.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9bbc5e4e593424e099fe23ce2ab6d69a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Internal/ValueFormatter.cs

@@ -0,0 +1,103 @@
+using System;
+using System.Collections.Generic;
+
+using Newtonsoft.Json;
+
+namespace BACKND.Database.Internal
+{
+    /// <summary>
+    /// SQL 쿼리용 값 포맷팅 유틸리티
+    /// </summary>
+    public static class ValueFormatter
+    {
+        /// <summary>
+        /// SQL 함수 및 키워드 목록
+        /// </summary>
+        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"
+        };
+
+        /// <summary>
+        /// 값이 SQL 함수 또는 키워드인지 확인
+        /// </summary>
+        public static bool IsSqlFunctionOrKeyword(string value)
+        {
+            if (string.IsNullOrWhiteSpace(value)) return false;
+            return SqlFunctionsAndKeywords.Contains(value.Trim());
+        }
+
+        /// <summary>
+        /// 값을 SQL 쿼리용 문자열로 포맷팅
+        /// </summary>
+        public 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("\\", "\\\\")}'";
+        }
+
+        /// <summary>
+        /// 값을 문자열로 변환
+        /// </summary>
+        public 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();
+        }
+    }
+}

package/Internal/ValueFormatter.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ef79cfe7f35884c249bf8d5435da580d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Internal.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 619842c6cc805448380803b23bf2b370
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Network/DatabaseExecutor.cs

@@ -0,0 +1,171 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+
+using Newtonsoft.Json;
+
+using UnityEngine;
+using UnityEngine.Networking;
+
+namespace BACKND.Database.Network
+{
+    public static class DatabaseExecutor
+    {
+        //private static readonly string SERVER_URL = "http://localhost:10002";
+        //private static readonly string SERVER_URL = "https://api.alpha.thebackend.io";
+        //private static readonly string SERVER_URL = "https://api.beta.thebackend.io";
+
+        private static readonly string SERVER_URL = "https://api.thebackend.io";
+        private static readonly string ENDPOINT = "/v1/database/store";
+        private static readonly int MAX_RETRIES = 3;
+        private static readonly float RETRY_DELAY = 1.0f;
+        private static readonly int REQUEST_TIMEOUT = 60;
+
+        public static async BTask<Response> Execute(DatabaseRequest request, Dictionary<string, string> headers, CancellationToken cancellationToken = default)
+        {
+            var query = ReplacePlaceholders(request.Query, request.Parameters);
+
+            var requestBody = new StoreRequest
+            {
+                query = query
+            };
+
+            var json = JsonConvert.SerializeObject(requestBody);
+            var bytes = Encoding.UTF8.GetBytes(json);
+
+            int retryCount = 0;
+            Exception lastException = null;
+
+            while (retryCount <= MAX_RETRIES)
+            {
+                using var webRequest = new UnityWebRequest($"{SERVER_URL}{ENDPOINT}", "POST");
+                webRequest.uploadHandler = new UploadHandlerRaw(bytes);
+                webRequest.downloadHandler = new DownloadHandlerBuffer();
+                webRequest.timeout = REQUEST_TIMEOUT;
+
+                webRequest.SetRequestHeader("Content-Type", "application/json");
+                foreach (var header in headers)
+                {
+                    webRequest.SetRequestHeader(header.Key, header.Value);
+                }
+
+                try
+                {
+                    using var timeoutCts = new CancellationTokenSource();
+                    using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutCts.Token);
+
+                    timeoutCts.CancelAfter(REQUEST_TIMEOUT * 1000);
+
+                    var operation = webRequest.SendWebRequestAsBTask(linkedCts.Token);
+
+                    try
+                    {
+                        var result = await operation;
+
+                        if (result.result == UnityWebRequest.Result.Success)
+                        {
+                            var responseText = result.downloadHandler.text;
+                            var response = JsonConvert.DeserializeObject<Response>(responseText);
+
+                            return response;
+                        }
+                        else
+                        {
+                            lastException = new Exception($"Network error: {result.error}");
+                            retryCount++;
+
+                            if (retryCount <= MAX_RETRIES)
+                            {
+                                Debug.LogWarning($"[DatabaseExecutor] Retry {retryCount}/{MAX_RETRIES}: {lastException.Message}");
+                                await BTask.Delay(RETRY_DELAY * retryCount);
+                                continue;
+                            }
+                        }
+                    }
+                    catch (OperationCanceledException)
+                    {
+                        webRequest.Abort();
+
+                        if (timeoutCts.IsCancellationRequested && !cancellationToken.IsCancellationRequested)
+                        {
+                            lastException = new Exception($"Request timeout after {REQUEST_TIMEOUT} seconds");
+                            retryCount++;
+
+                            if (retryCount <= MAX_RETRIES)
+                            {
+                                Debug.LogWarning($"[DatabaseExecutor] Retry {retryCount}/{MAX_RETRIES}: {lastException.Message}");
+                                await BTask.Delay(RETRY_DELAY * retryCount);
+                                continue;
+                            }
+                        }
+                        else
+                        {
+                            throw;
+                        }
+                    }
+                }
+                catch (OperationCanceledException)
+                {
+                    throw;
+                }
+                catch (Exception ex)
+                {
+                    lastException = ex;
+                    retryCount++;
+
+                    if (retryCount <= MAX_RETRIES)
+                    {
+                        Debug.LogWarning($"[DatabaseExecutor] Retry {retryCount}/{MAX_RETRIES}: {ex.Message}");
+                        await BTask.Delay(RETRY_DELAY * retryCount);
+                        continue;
+                    }
+                }
+            }
+
+            return new Response
+            {
+                Success = false,
+                Error = $"Request failed after {MAX_RETRIES} retries: {lastException?.Message ?? "Unknown error"}"
+            };
+        }
+
+        private static string ReplacePlaceholders(string query, Dictionary<string, object> parameters)
+        {
+            if (parameters == null || parameters.Count == 0)
+                return query;
+
+            var result = query;
+            foreach (var param in parameters)
+            {
+                var value = FormatValue(param.Value);
+                result = result.Replace(param.Key, value);
+            }
+
+            return result;
+        }
+
+        private static string FormatValue(object value)
+        {
+            if (value == null)
+                return "NULL";
+
+            if (value is string str)
+                return $"'{str.Replace("'", "''")}'";
+
+            if (value is bool b)
+                return b ? "true" : "false";
+
+            if (value is DateTime dt)
+                return $"'{dt:yyyy-MM-ddTHH:mm:ss.fffZ}'";
+
+            return value.ToString();
+        }
+
+        private class StoreRequest
+        {
+            [JsonProperty("query")]
+            public string query;
+        }
+    }
+}

package/Network/DatabaseExecutor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a3d4cdef477a7429a9658bad2bb26262
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: