简体中文(ZH-CN) English(EN) 繁体中文(ZH-TW) 日本語(JA) 한국어(KO) Melayu(MS) Français(FR) Deutsch(DE)
집 > 데이터 베이스 > MySQL 튜토리얼 > 본문

간단한 ORM 생성(CURD 작업 클래스)

黄舟
풀어 주다： 2016-12-28 13:56:48
원래의
1150명이 탐색했습니다.

SQL 실행 클래스

CURD 연산 클래스

기타 간장 클래스


CURD 연산 클래스는 조건 변환을 담당한다. 사용자가 제공한 SQL 문은 실행을 위해 IHelper에 제공되고 Model 컬렉션을 반환합니다.

간단한 ORM 생성(CURD 작업 클래스)

CURD 클래스에는 공용 메서드를 추상화하는 인터페이스가 필요합니다. 일반 인터페이스를 확장하고 제공합니다. 단순화를 위해 당분간 JOIN 구현은 제공하지 않습니다. 대신 데이터베이스 뷰를 사용하면 됩니다. 

public interface IDbOper<T> : IDisposable where T : new()
    {
       object Insert(T m);//新增MODEL，返回ID，简单起见只做了INT自增
       int Update(string str);//批量更新
       int Update(T m);//Model更新
       int Delete();//删除
        ///拼接字符版，需要自己防止注入，特别是Orderby容易被忽视
       IDbOper<T> Select(string sl);//选择字段
       IDbOper<T> Where(string sl);
       IDbOper<T> Orderby(string orby);
        ///Expression版重载，转化为参数方式执行，以参数方式拼接无注入风险 
       IDbOper<T> Select(Expression<Func<T, object>> sl);
       IDbOper<T> Where(Expression<Func<T, bool>> sl);
       ///Dictionary版重载，需要牛顿ＪＳＯＮ帮忙转化，以参数方式拼接无注入风险,此方式用于“等于”等查询方式，不提供大于小于查询
       IDbOper<T> Orderby(Dictionary<string, string> dic);
       IDbOper<T> Where(Dictionary<string, object> dic);
        ///
       IDbOper<T> Index(int i);
       IDbOper<T> Size(int i);
       T First();//获取第一个model
       void BegTran();
       void RollBack();
       void Commit();
       M ToObj<M>(Func<IDataReader, M> func,string sql);
       List<T> ToList();
　　　　　//转化为其他类型，若开启了事务的话需要此转化
       IDbOper<M> ToOper<M>() where M : new();
       int Count();
       //直接执行SQL语句
       int DoCommand(string sql, bool issp);
    }
로그인 후 복사

저는 JQ의 연산 방식을 선호하므로 이 실행을 가져오고 싶습니다. 더 이상 고민하지 않고 2개의 모델을 정의하고 작업 클래스를 인스턴스화합니다. 

public class User
{
     [Key]
     public int ID{get;set;}
     public string UserName{get;set;}
     public string Password{get;set;}
}
public class NewUser
{
     [Key]
     public int ID{get;set;}
     public string UserName{get;set;}
     public string Password{get;set;}
}
var db=new DbOper<User>(new DbInfo(){DbType="…",DbConntion="…"});
로그인 후 복사

표현식 실행

User a=db.Select(u=>new{u.ID}).Where(u=>u.ID==54).First();
로그인 후 복사

텍스트 접합 실행

User a=db.Select("*").Where("ID=54").First();
로그인 후 복사

사전 접합 실행

User a=db.Select("*").Where(new Dictionary<string, object>(){Key="ID",Value=54}).First();
로그인 후 복사

페이징 코드

List<User> lt=db.Select("*").Where("ID>0").Orderby("ID Desc").Index(2).Size(20).ToList();
로그인 후 복사

트랜잭션 사용

db.BegTran();
try{
    int b=db.Where("ID=54").Delete();//user表删除ID=54
    int c=db.ToOper<NewUser>().Insert(new NewUser(){UserName="…",Password="…"});//newuser表新增一条记录
    db.Commit();
}
catch{db.RollBack();}
로그인 후 복사

삽입, 업데이트, 삭제, Count, ToList 메소드가 호출되면 텍스트가 다시 연결됩니다. IHelper를 호출하여 SQL 문을 실행한 후 Clear()가 자동으로 호출되어 저장된 위치, 선택 및 기타 정보가 정리됩니다.

다음은 제가 제공하는 오퍼레이션 클래스를 구현한 것입니다. 자신만의 오퍼레이션 클래스를 구현할 수도 있습니다. 

internal class DbOper<T> :IDbPhysiceOper<T>, IDisposable where T : new()
    {
        internal IHelper db;
        internal StringBuilder where;
        internal StringBuilder select;
        internal StringBuilder orderby;
        internal List<IDataParameter> ps;
        internal StringBuilder sqlinfo;
        internal int index = 0;
        internal int size = OrmGlobal.PageSize;//提供一个默认分页大小
        private DbOper(IHelper h, StringBuilder w, StringBuilder s, StringBuilder or, List<IDataParameter> p,StringBuilder sql)
        {
            db = h;
            where = w;
            select = s;
            orderby = or;
            sqlinfo = sql;
            ps = p;
        }
        internal DbOper(DbInfo info)
        {            //db为上篇上定义的数据库操作类,分分种切换到其他数据库            if (info.DbType.Equals("mssql"))
            {
                db = new Helper.Mssql(info.DbConntion);
            }
            else if (info.DbType.Equals("msmars"))
            {
                db = new Helper.MsMars(info.DbConntion);
            }
            else if (info.DbType.Equals("mysql"))
            {
                db = new Helper.Mysql(info.DbConntion);
            }
            where = new StringBuilder();
            select = new StringBuilder();
            orderby = new StringBuilder();
            sqlinfo = new StringBuilder();
            ps = new List<IDataParameter>();
        }
        public object Insert(T m)
        {
            try
            {
                StringBuilder fields = new StringBuilder();
                StringBuilder values = new StringBuilder();
                List<IDataParameter> lt = new List<IDataParameter>();
                string tp = string.Empty; object o = null;
                foreach (var n in m.GetType().GetProperties())
                {
                    if (n.GetCustomAttributes(typeof(ExcludeColumn), false).Length > 0) { continue; }
                    if (n.GetCustomAttributes(typeof(Key), false).Length > 0) { continue; }
                    o = n.GetValue(m,null);//4.5o = n.GetValue(m);
                    if (o == null) { continue; }
                    fields.Append(n.Name + ",");
                    tp = db.ParStr(n.Name);
                    values.Append(tp + ",");
                    lt.Add(db.Cp(tp, o));
                }
                if (fields.Length > 0) { fields.Length--; }
                if (values.Length > 0) { values.Length--; }
                tp = "INSERT INTO " + typeof(T).Name + "(" + fields.ToString() + ")VALUES(" + values.ToString() + ") " + db.GetIdStr;
                if (OrmGlobal.isrecord) { Record(tp); }
                object a = db.ExectueScalar(tp, lt, false);
                Clear();
                return a;
            }
            catch
            {
                OrmGlobal.DoErr(sqlinfo.ToString()); throw;
            }
        }
        public int Update(string str)
        {
            try
            {
                string tp = "UPDATE " + typeof(T).Name + " SET " + str + (where.Length > 0 ? " WHERE " + where : string.Empty);
                if (OrmGlobal.isrecord) { Record(tp); }
                int i = db.ExecuteQuery(tp, ps, false);
                Clear();
                return i;
            }
            catch
            {
                OrmGlobal.DoErr(sqlinfo.ToString()); throw;
            }
        }
        public int Update(T m)
        {
            try
            {
                StringBuilder sb = new StringBuilder();
                sb.Append("UPDATE " + typeof(T).Name + " SET ");
                List<IDataParameter> lt = new List<IDataParameter>();
                object o = null;
                foreach (var n in m.GetType().GetProperties())
                {//需要定义一个特性Key,以便更新Model                    o = n.GetValue(m,null);//4.5o = n.GetValue(m);
                    if (o == null) { continue; }
                    if (n.GetCustomAttributes(typeof(Key), false).Length > 0)
                    {
                        where.Append((where.Length > 0 ? " AND " : string.Empty) + n.Name + "=" + db.ParStr(n.Name));
                        lt.Add(db.Cp(db.ParStr(n.Name), o));
                        continue;
                    }
                    sb.Append(n.Name + "=" + db.ParStr(n.Name) + ",");
                    lt.Add(db.Cp(db.ParStr(n.Name), o));
                }
                if (sb.Length > 0) { sb.Length--; }
                if (where.Length > 0) { sb.Append(" WHERE " + where); }
                var sql = sb.ToString();
                if (OrmGlobal.isrecord) { Record(sql); }
                int i = db.ExecuteQuery(sql, lt, false);
                Clear();
                return i;
            }
            catch
            {
                OrmGlobal.DoErr(sqlinfo.ToString()); throw;
            }
        }
        public int Delete()
        {
            try
            {
                string sql = "DELETE FROM " + typeof(T).Name + (where.Length > 0 ? " WHERE " + where : string.Empty);
                if (OrmGlobal.isrecord) { Record(sql); }
                int i = db.ExecuteQuery(sql, ps, false);
                Clear();
                return i;
            }
            catch
            {
                OrmGlobal.DoErr(sqlinfo.ToString()); throw;
            }
        }
        public IDbOper<T> Select(string sl)
        {
            if (string.IsNullOrEmpty(sl)) { return this; }
            select.Append((select.Length > 0 ? "," : string.Empty) + sl); return this;
        }
        public IDbOper<T> Select(Expression<Func<T, object>> sl)
        {
            string tp=null;
            using (var tp1 = new LinqVisitor())
            {
                tp=tp1.VisitNew(sl.Body as NewExpression);
            }
            return Select(tp);
        }
        public IDbOper<T> Where(Dictionary<string, object> dic)
        {
            if (dic == null || dic.Count == 0) { return this; }
            var sb = new StringBuilder(); string tp;
            foreach (var n in dic)
            {
                if (sb.Length > 0) { sb.Append(" AND "); }
                sb.Append(n.Key);
                if (n.Value is string)
                {
                    tp = n.Value.ToString();
                    if (tp.Substring(tp.Length - 1, 1) == "*")
                    {
                        sb.Append(" LIKE ");
                        tp = tp.Substring(0, tp.Length - 1) + "%";
                    }
                    else { sb.Append("="); }
                    ps.Add(db.Cp(db.ParStr(n.Key), tp));
                }
                else
                {
                    sb.Append("=");
                    ps.Add(db.Cp(db.ParStr(n.Key), n.Value));
                }
                sb.Append(db.ParStr(n.Key));
            }
            Where(sb.ToString());
            return this;
        }
        public IDbOper<T> Where(string sl)
        {
            if (string.IsNullOrEmpty(sl)) { return this; }
            where.Append((where.Length > 0 ? " AND " : string.Empty) + sl); return this;
        }
        public IDbOper<T> Where(Expression<Func<T, bool>> sl)
        {
            List<object> tp=null;             //需要解析表达式树            using (var tp1 = new LinqVisitor())
            {
                tp = tp1.Visit(sl) as List<object>;
                StringBuilder sb = new StringBuilder(); string s = string.Empty;
                for (int i = 0; i < tp.Count; i += 4)
                {
                    s = db.ParStr(tp[i].ToString());
                    sb.Append(tp[i].ToString() + tp[i + 1].ToString() + s);
                    if (i + 4 < tp.Count) { sb.Append(tp[i + 3]); }
                    ps.Add(db.Cp(s, tp[i + 2]));
                }
                Where(sb.ToString());
            }
            return this;
        }
        public IDbOper<T> Orderby(string orby)
        {
            if (string.IsNullOrEmpty(orby)) { return this; }
            orderby.Append((orderby.Length > 0 ? "," : string.Empty) + orby); return this;
        }
        public IDbOper<T> Orderby(Dictionary<string, string> dic)
        {
            if (dic.Count == 0) { return this; }
            StringBuilder sb = new StringBuilder();
            foreach (var n in dic.Keys)
            {
                if(string.Compare("DESC",dic[n],true)!=0 && string.Compare("ASC",dic[n],true)!=0){continue;}
                sb.Append(n + " " + dic[n] + ",");
            }
            if (sb.Length > 0) { sb.Length--; }
            Orderby(sb.ToString()); return this;
        }
        public IDbOper<T> Index(int i) { if (i > 0) { index = i; } return this; }
        public IDbOper<T> Size(int i) { if (i > 0) { size = i; } return this; }
        public void BegTran() { db.BegTran(); }
        public void RollBack() { db.RollBack(); }
        public void Commit() { db.Commit(); }
        public void Clear()
        {
            where.Length = 0; select.Length = 0; orderby.Length = 0; ps.Clear(); index = 0; size = OrmGlobal.size;
        }
        public M ToObj<M>(Func<IDataReader, M> func, string sql)
        {
            try
            {
                if (OrmGlobal.isrecord) { Record(sql); }
                var rd = db.ExectueReader(sql, ps, false);
                M t = func(rd);
                rd.Close(); Clear();
                return t;
            }
            catch
            {
                OrmGlobal.DoErr(sqlinfo.ToString()); throw;
            }
        }
        public List<T> ToList() 
        {
            string sql = GetSql();
            return ToObj<List<T>>(rd => ToList(rd),sql);
        }        //返回List<T>类型        public List<T> ToList(IDataReader rd)
        {
            var lt = new List<T>();
            var set = DelegateExpr.SetMethod(typeof(T));//ExpressTree实现属性绑定,以提高Model赋值性能，可以以反射代替
            while (rd.Read())
            {
                var m = new T();
                for (var i = 0; i < rd.FieldCount; i++)
                {
                    if (rd[i] == DBNull.Value || rd[i] == null) { continue; }
                    set(m, rd.GetName(i).ToLower(), rd[i]);
                }
                lt.Add(m);
            }
            return lt;
        }
        public string GetSql()
        {
            return db.CreateSql(select.ToString(), typeof(T).Name, where.ToString(), orderby.ToString(), size, index);
        }
        public IDbOper<M> ToOper<M>() where M:new()
        {
            Clear();
            return new DbOper<M>(db,where,select,orderby,ps,sqlinfo);
        }
        public int Count()
        {
            try
            {
                string sql = "SELECT COUNT(*) FROM " + typeof(T).Name + (where.Length > 0 ? " WHERE " + where : string.Empty);
                if (OrmGlobal.RecordLog) { Record(sql); }
                int i= (int)db.ExectueScalar(sql, ps, false);
                Clear();
                return i;
            }
            catch
            {
                OrmGlobal.DoErr(sqlinfo.ToString()); throw;
            }
        }
        public int DoCommand(string sql,bool issp)
        {
            int i=db.ExecuteQuery(sql,ps,issp);
            Clear();
            return i;
        }
        public void Dispose()
        {
            where = null; select = null; orderby = null; db.Dispose(); ps = null; sqlinfo = null; 
            GC.SuppressFinalize(this);
        }
        public T First()
        {
            var lt=Size(1).Index(1).ToList();
            if (lt.Count > 0) { return lt[0]; }
            return default(T);
        }
        ~DbOper()
        {
            Dispose();
        }
    }
로그인 후 복사

위 내용은 간단한 ORM 제작(CURD 연산 클래스) 내용입니다. 더 많은 관련 내용은 PHP 중국어 홈페이지(www.php.cn)를 참고해주세요!


관련 라벨：
ORM制作，CURD
원천：php.cn
이전 기사：MySQL 통계 합계 합계 선택 다음 기사：mysql 추가, 삭제, 수정, 쿼리-CURD 작업
본 웹사이트의 성명
본 글의 내용은 네티즌들의 자발적인 기여로 작성되었으며, 저작권은 원저작자에게 있습니다. 본 사이트는 이에 상응하는 법적 책임을 지지 않습니다. 표절이나 침해가 의심되는 콘텐츠를 발견한 경우 admin@php.cn으로 문의하세요.
저자별 최신 기사
최신 이슈
TYPO3 V11: "PHP 경고: 정의되지 않은 배열 키", $this->request->getArguments()가 비어 있습니다. 저는 typo3의 새로운 사용자입니다. 사용자를 표시하고 검색 창을 사용하여 필터링하는 플러그인을 만들었지만 내 페이지를 표시하려고 하면 다음 오류가 발생합니다:...
에서 2023-11-12 21:35:09
0
1
362
PHPMailer 정의되지 않은 유형 오류가 발생했습니다(Composer를 사용해도 작동하지 않음) 왜 "PHPMailer 정의되지 않은 유형" 오류가 발생하는지 모르겠습니다. 먼저 zip을 직접 다운로드하고 github에서 코드를 복사해 보았...
에서 2023-11-12 17:35:06
0
1
180
Laravel: GuzzleHttp\Exception\ConnectException: cURL 오류 7: 연결 실패 내 컨트롤러를 사용하여 원시 주체가 있는 타사 Api를 게시하려고 합니다. localhost에서 테스트하면 제대로 작동하지만 서버(Cpanel)에 프로젝트를 게시...
에서 2023-11-09 18:54:47
0
1
196
Laravel 8의 블레이드 자산을 사용하여 이미지를 표시하지만 리소스 하위 폴더에서 로드 저는 Laravel을 처음 접했으므로 양해해 주시기 바랍니다. Node/React에서 개발한 프레임워크를 Laravel에 복사하고 있습니다. 현재 저는 기본 아키...
에서 2023-11-09 12:47:02
0
1
314
Laravel Breeze를 설치하는 동안 Laravel Mix 오류가 발생했습니다. 새로운 Laravel 애플리케이션에 LaravelBreeze를 설치하려고 합니다. 모든 것이 잘 작동하지만 콘솔에 npmrundev를 입력하면 다음 오류가 계속 ...
에서 2023-11-07 23:05:02
0
1
299
관련 주제
더>
인기 추천
인기 튜토리얼
더>
관련 튜토리얼
인기 추천
최신 강좌
최신 다운로드
더>
웹 효과
웹사이트 소스 코드
웹사이트 자료
프론트엔드 템플릿
회사 소개 부인 성명 Sitemap
PHP 중국어 웹사이트：공공복지 온라인 PHP 교육，PHP 학습자의 빠른 성장을 도와주세요！