//
                主要是类反射出来的字段进行一些处理方便形成数据库语言
                public
                class
                 Column
{
    
                public
                 Type ColumnType;

    
                public
                string
                 TableType
    {
        
                get
                
        {
            
                if
                 (IsPrimaryKey)
                
                return
                "
                INTEGER PRIMARY KEY
                "
                ;
            
                else
                return
                 To_TableType(ColumnType);
        }
    }

    
                //

                public
                bool
                 IsPrimaryKey {
        
                get
                 {
            
                return ColumnName.ToLower().StartsWith("id") && ColumnType == typeof(int);
        }
    }

    publicstring To_TableType(Type type)
    {
        if (type == typeof(int)) return ColType.INTEGER.ToString();

        if (type == typeof(string)) return ColType.TEXT.ToString();

        thrownew Exception("Wrong Type");
    }

    publicstring ColumnName;

    //Column Value    MyProperty Property;

    publicobject ColumnValue
    {
        get
        {
            if (Property == null) returnnull;

            if (ColumnType == typeof(string))
            {
                return ((MyProperty<string>)(Property)).GetValue();
            }
            elseif (ColumnType == typeof(String))
            {
                return ((MyProperty<String>)(Property)).GetValue();
            }
            elseif (ColumnType == typeof(int))
            {
                return ((MyProperty<int>)(Property)).GetValue();
            }
            //else if (ColumnType == typeof(Enum))
            //{
            //    return ((MyProperty<int>)(Property)).GetValue();
            //}else
            {
                returnnull;
            }
        }
    }

    public Column(Type ColumnType, string ColumnName, object value)
    {
        this.ColumnType = ColumnType;

        this.ColumnName = ColumnName;

        if (ColumnType == typeof(string))
        {
            string v = Convert.ToString(value);

            Property = new MyProperty<string>();
            ((MyProperty<string>)(Property)).SetValue(v);
        }
        elseif (ColumnType == typeof(String))
        {
            String v = Convert.ToString(value);

            Property = new MyProperty<String>();
            ((MyProperty<String>)(Property)).SetValue(v);
        }
        elseif (ColumnType == typeof(int))
        {
            int v = Convert.ToInt32(value);

            Property = new MyProperty<int>();
            ((MyProperty<int>)(Property)).SetValue(v);
        }
        //else if (ColumnType == typeof(Enum))
        //{
        //    int v = Convert.ToInt32(value);

        //    Property = new MyProperty<int>();
        //    ((MyProperty<int>)(Property)).SetValue(v);
        //}else
        {
            Debuger.LogError("Column Construct Not Right Type :" + ColumnType.ToString());
        }

    }
}

publicclass MyProperty
{
}

publicclass MyProperty<T> : MyProperty
{
    public MyProperty()
    {
#if UNITY_FLASH
            _isValue = false;
#else
        _isValue = typeof(T).IsValueType;
#endif
    }

    publicbool IsOfType(System.Type t)
    {
        return t == typeof(T);
    }

    public MyProperty(T value)
        : this()
    {
        _value = value;
    }

    public T GetValue()
    {
        return _value;
    }

    protectedvirtualbool IsValueDifferent(T value)
    {
        return !_value.Equals(value);
    }

    privatebool IsClassDifferent(T value)
    {
        return !_value.Equals(value);
    }

    publicvirtualvoid SetValue(T value)
    {
        if (_changing)
            return;
        _changing = true;

        bool changed;

        if (_isValue)
        {
            changed = IsValueDifferent(value);
        }
        else
        {
            // Value types are handled differently via cached typeof(T).IsValueType checkup
            // ReSharper disable CompareNonConstrainedGenericWithNull
            changed = (value == null && _value != null) ||
                      (value != null && _value == null) ||
                      (_value != null && IsClassDifferent(value));
            // ReSharper restore CompareNonConstrainedGenericWithNull        }
        if (changed)
        {
            _value = value;
            //OnValueChanged();        }
        _changing = false;
    }


    privatebool _changing;
    private T _value;
    privatereadonlybool _isValue;
}

                //
                数据库字段类型
                public
                enum
                 ColType
{
    INTEGER,
    TEXT,
    REAL,
    BLOB
}


                public
                class DBUtil<T>
{
    publicstatic Column[] GetColumnsByType(T arg)
    {
        FieldInfo[] fields = arg.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance);

        int field_len = fields.Length;

        if (fields == null || field_len < 1)
        {
            returnnull;
        }

        Column[] tableType = new Column[field_len];
        for (int i = 0; i < field_len; i++)
        {
            string Cur_Name = fields[i].Name;

            Type Cur_Type = fields[i].FieldType;

            object Value = fields[i].GetValue(arg);

            tableType[i] = new Column(Cur_Type, Cur_Name, Value);

            //Debuger.Log("name : " + tableType[i].ColumnName + "  type :" + tableType[i].TableType);        }
        return tableType;
    }

    publicstaticvoid CreateTable(ref SQLiteDB db, T arg)
    {
        SQLiteQuery qr;

        Type type = arg.GetType();
        string TableName = type.Name;

        string queryDelete = "DROP TABLE IF EXISTS " + TableName + ";";
        qr = new SQLiteQuery(db, queryDelete);
        qr.Step();
        qr.Release();


        Column[] Columns = GetColumnsByType(arg);
        if (Columns == null || Columns.Length < 1)
        {
            Debug.LogError("Type is Wrong");
            return;
        }


        Debug.Log("NowCreate:" + TableName);
        //CREATE TABLE IF NOT EXISTS test_values (id INTEGER PRIMARY KEY, str_field TEXT, blob_field BLOB);string queryCreate = queryCreateCommond(TableName, Columns);
        qr = new SQLiteQuery(db, queryCreate);
        qr.Step();
        qr.Release();
    }
    publicstaticstring queryCreateCommond(string TableName, Column[] Columns)
    {
        string queryCreate = "CREATE TABLE IF NOT EXISTS " + TableName + "(" + Columns[0].ColumnName + "" + Columns[0].TableType;

        for (var i = 1; i < Columns.Length; i++)
        {
            queryCreate += ", " + Columns[i].ColumnName + "" + Columns[i].TableType;
        }
        queryCreate += ");";

        return queryCreate;
    }

    publicstaticvoid ArrayInsertTable(ref SQLiteDB db, T[] Records)
    {

        for (int i = 0; i < Records.Length; i++)
        {
            InsertTable(ref db, Records[i]);
        }
    }   

    //注意，主键null自动增加 否则就是要自己控制生成
    //自己选择 我这里是自己控制生成的publicstaticvoid InsertTable(ref SQLiteDB db, T Record)
    {
        SQLiteQuery qr;

        Type type = Record.GetType();
        string TableName = type.Name;

        Column[] Columns = GetColumnsByType(Record);
        if (Columns == null || Columns.Length < 1)
        {
            Debug.LogError("Type is Wrong");
            return;
        }

        Debug.Log("Now Insert:" + TableName);
        //"INSERT INTO test_values (str_field,blob_field) VALUES(?,?);";string queryInsert = queryInsertCommand(TableName, Columns);
        qr = new SQLiteQuery(db, queryInsert);
        foreach (var item in Columns)
        {
            //注意，主键null的情况 是可以的 这样一来 就自动增加了 主键
            //if (item.IsPrimaryKey)
            //    qr.BindNull();
            //else            qr.Bind(item.ColumnValue.ToString());
        }
        qr.Step();
        qr.Release();
    }
    publicstaticstring queryInsertCommand(string TableName, Column[] column)
    {

        int RowLength = column.Length;

        string queryInsert = "INSERT INTO " + TableName + "(" + column[0].ColumnName;
        for (int i = 1; i < RowLength; i++)
        {
            queryInsert += "," + column[i].ColumnName;
        }
        queryInsert += ") VALUES (?";
        for (int i = 1; i < RowLength; i++)
        {
            queryInsert += ",?";
        }
        queryInsert += ");";

        return queryInsert;
    }

    //目前 根据Id 索引更新 不够完善publicstaticvoid UpdateTableAccordingId(ref SQLiteDB db, T arg)
    {
        SQLiteQuery qr;

        Type type = arg.GetType();
        string TableName = type.Name;

        Column[] Columns = GetColumnsByType(arg);
        if (Columns == null || Columns.Length < 1)
        {
            Debug.LogError("Type is Wrong");
            return;
        }

        Column key = null;
        Column[] normal  = null;
        Debug.Log("Now Insert:" + TableName);
        
        //"UPDATE MyFirstTable SET b = ‘bbbb‘ ,c = ‘bbbb‘ WHERE id = 1;" 如果使用通配符不用加‘‘string queryUpdate = queryUpdateCommand(TableName, Columns, ref normal, ref key);
        //Debuger.Log(queryUpdate);
        qr = new SQLiteQuery(db, queryUpdate);
        foreach (var item in normal)
        {
            qr.Bind(item.ColumnValue.ToString());
        }
        qr.Bind(key.ColumnValue.ToString());
        
        qr.Step();
        qr.Release();
    }

    publicstaticstring queryUpdateCommand(string TableName, Column[] Columns, ref Column[] normal, ref Column key)
    {

        int RowLength = Columns.Length;

        normal = GetNormalColumn(Columns);
        //"UPDATE test_tbl set b="****",c ="*****" where id=1;"string queryUpdate = "UPDATE " + TableName + " SET " + normal[0].ColumnName + " = ? ";
        for (int i = 1; i < normal.Length; i++)
        {
            queryUpdate += "," + normal[i].ColumnName + " = ? ";
        }
        
        key = GetPrimaryColumn(Columns);
        queryUpdate += "WHERE " + key.ColumnName + " = ? ;";

        return queryUpdate;
    }

    

    //得到主键字段static Column GetPrimaryColumn(Column[] Columns)
    {
        foreach (var item in Columns)
        {
            if (item.IsPrimaryKey) return item;
        }
        returnnull;
    }
    //普通字段static Column[] GetNormalColumn(Column[] Columns)
    {
        List<Column> tmp = new List<Column>();

        foreach (var item in Columns)
        {
            if (!item.IsPrimaryKey)
                tmp.Add(item);
        }
        return tmp.ToArray();
    }
}