kiss.data的简单记录
==
[github地址](https://github.com/sdming/Kiss.Data)
kiss.data是golang的数据库访问类库[kdb](https://github.com/sdming/kdb)的c#版本， 最初是先有c#版本的，后来根据golang的设计重构了。
刚写完主干部分，还在测试中。
特性
==
* 支持主流数据库
* 支持常见ORM操作
* 智能数据转换
* ...
基本类型
==
`DbContent`类
封装对db的一些基本操作。
`IDataObjectAdapter`接口
对象字段访问的接口， 包含四个方法
```
public interface IDataObjectAdapter
{
void Set(string field, object value); //设置字段的值
object Get(string field); //获取字段的值
IEnumerable Fields(); //获取所有字段
bool Contains(string field); //判断字段是否存在, 可能多余，因为根据Fields的结果也可以判断字段是否存在
}
```
`ISqlExpression`接口
Sql表达式的接口，定义如下
```
public interface ISqlExpression
{
NodeType NodeType();
}
```
环境
==
假设数据库连接字符串配置如下
```
```
表结构如下
```
CREATE TABLE [ttable](
[pk] [bigint] IDENTITY(1,1) NOT NULL,
[cbool] [bit] NULL,
[cint] [int] NULL,
[cfloat] [float] NULL,
[cnumeric] [numeric](10, 4) NULL,
[cstring] [nvarchar](100) NULL,
[cdatetime] [datetime] NULL,
[cguid] [uniqueidentifier] NULL,
[cbytes] [binary](100) NULL,
CONSTRAINT [PK_ttable] PRIMARY KEY CLUSTERED
(
[pk] ASC
)
)
```
代码中的对象定义如下
```
[DbTable(Name = "ttable")]
public class CEntity
{
[DbColumn(IsKey = true, UpdateAble = false, InsertAble = false)]
public int PK { get; set; }
public bool CBool { get; set; }
public int CInt { get; set; }
public float CFloat { get; set; }
[DbColumn(Name = "CNumeric")]
public decimal ColNumeric { get; set; }
public string CString { get; set; }
public DateTime CDateTime;
public Guid CGuid;
}
```
直接执行sql 脚本
==
用IDataObjectAdapter传参数
```
using (DbContent db = new DbContent("mssql"))
{
var data = Kiss.Core.Adapter.Dictionary();
data.Set("cint", 101);
data.Set("pk", 11606);
db.TextNonQuery("update TTABLE set cint = @cint where pk = @pk", data);
}
```
用params object[]传参数
```
using (DbContent db = new DbContent("mssql"))
{
var i = db.TextNonQuery("update TTABLE set cint = @cint where pk = @pk", 102, 11606);
}
```
创建Text对象
```
using (DbContent db = new DbContent("mssql"))
{
var exp = new Kiss.Data.Expression.Text("update TTABLE set cint = @cint where pk = @pk")
.Set("cint", 103)
.Set("pk", 11606);
db.ExecuteNonQuery(exp);
}
```
执行存储过程
==
测试存储过程定义如下
```
create procedure [usp_query](@cint int)
as
begin
select * from ttable where cint > @cint;
end;
create procedure [usp_exec](@cint int)
as
begin
delete from ttable where cint = @cint;
end;
create procedure [usp_inout](@x int, @y int output, @sum int output)
as
begin
set @sum = @x + @y;
set @y = 2 * @y
end;
```
用IDataObjectAdapter传参数
```
using (DbContent db = new DbContent("mssql"))
{
Dictionary<string, object> data = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
data["cint"] = 101;
var table = db.ProcedureReader("usp_query", Kiss.Core.Adapter.Dictionary(data)).ToTable();
}
```
用params object[]传参数
```
using (DbContent db = new DbContent("mssql"))
{
db.ProcedureNonQuery("usp_exec", 11606);
}
```
返回output参数
```
using (DbContent db = new DbContent("mssql"))
{
var data = Kiss.Core.Adapter.Dictionary();
data.Set("x", 2);
data.Set("y", 7);
IExecuteResult r;
db.ProcedureNonQuery("usp_inout", data, out r);
var output = r.Output();
Console.WriteLine("y:{0},sum:{1}", output["y"], output["sum"]);
}
```
通过Procedure对象执行
```
using (DbContent db = new DbContent("mssql"))
{
var exp = new Kiss.Data.Expression.Procedure("usp_exec")
.Set("cint", 64);
db.ExecuteNonQuery(exp);
}
```
如果定义了存储过程对应的接口，可以通过动态代理执行，比如接口定义如下
```
public interface IPorxyTest
{
IDataReader usp_query(int cint);
[DbProcedure(Name = "usp_exec")]
IDataReader Exec([DbParameter(Name = "cint")] int c);
IDataReader usp_inout(int x, ref int y, out int sum);
}
```
可以这么执行
```
using (DbContent db = new DbContent("mssql"))
{
IPorxyTest proxy = FunctionProxy.Create(db);
var reader = proxy.usp_query(101);
reader.Dispose();
}
using (DbContent db = new DbContent("mssql"))
{
IPorxyTest proxy = FunctionProxy.Create(db);
var reader = proxy.Exec(101);
Console.WriteLine(reader.RecordsAffected);
reader.Dispose();
}
using (DbContent db = new DbContent("mssql"))
{
int x = 3;
int y = 7;
int sum;
IPorxyTest proxy = FunctionProxy.Create(db);
proxy.usp_inout(x, ref y, out sum);
Console.WriteLine("y:{0},sum:{1}", y, sum);
}
```
Insert
==
通过insert对象执行
```
using (DbContent db = new DbContent("mssql"))
{
var insert = new Kiss.Data.Expression.Insert("ttable")
.Set("cbool", true)
.Set("cint", 42)
.Set("cfloat", 3.14)
.Set("cnumeric", 1.1)
.Set("cstring", "string")
.Set("cdatetime", "2004-07-24");
db.ExecuteNonQuery(insert);
}
```
通过IDataObjectAdapter执行
```
using (DbContent db = new DbContent("mssql"))
{
var data = Kiss.Core.Adapter.Dictionary();
data.Set("A_cbool", true);
data.Set("A_cint", 42);
data.Set("A_cfloat", 3.14);
data.Set("A_cnumeric", 1.1);
data.Set("A_cstring", "string");
data.Set("A_cdatetime", "2004-07-24");
db.Table("ttable").Insert(data, (x)=> "A_" + x, null, new string[]{"A_cint"});
}
```
通过ActiveEntity执行
```
using (DbContent db = new DbContent("mssql"))
{
var data = CEntity.NewEntity();
ActiveEntity ae = new ActiveEntity(db);
var pk = ae.Add(data);
Console.WriteLine(pk);
}
```
Update
==
通过Update对象执行
```
using (DbContent db = new DbContent("mssql"))
{
var update = new Kiss.Data.Expression.Update("ttable");
update
.Set("cstring", "new string")
.Set("cdatetime", DateTime.Now)
.Limit(10)
.Where
.EqualsTo("cint", 101);
db.ExecuteNonQuery(update);
}
```
通过IDataObjectAdapter执行
```
using (DbContent db = new DbContent("mssql"))
{
var data = Kiss.Core.Adapter.Dictionary();
data.Set("cint", 420);
data.Set("cfloat", 3.141);
data.Set("cnumeric", 1.12);
db.Table("ttable").Update(data, "cint", 101);
}
```
更新字段
```
using (DbContent db = new DbContent("mssql"))
{
var where = new Where()
.EqualsTo("cint", 101);
db.Table("ttable").UpdateColumn("cstring", "a string", where);
}
```
通过主键更新
```
using (DbContent db = new DbContent("mssql"))
{
CEntity entity = CEntity.NewEntity();
ActiveEntity ae = new ActiveEntity(db);
ae.UpdateByKey(entity, 11606);
}
```
根据字段更新
```
using (DbContent db = new DbContent("mssql"))
{
CEntity entity = CEntity.NewEntity();
ActiveEntity ae = new ActiveEntity(db);
ae.UpdateByFields(entity, (x) => x.CInt, 101);
}
```
根据lamda条件更新
```
using (DbContent db = new DbContent("mssql"))
{
var data = new Dictionary<string, object>();
data["cstring"] = "some string";
data["cfloat"] = 3.14 * 3.14;
ActiveEntity ae = new ActiveEntity(db);
ae.UpdateFields((x) => x.CInt > 101 && x.CInt < 202, data);
}
```
Query
==
通过Query对象执行
```
using (DbContent db = new DbContent("mssql"))
{
var query= new Data.Expression.Query("ttable");
query.Where
.EqualsTo("cint" , 10100)
.EqualsTo("cint", 20200);
var reader = db.ExecuteReader(query);
reader.Dispose();
}
```
根据列查询
```
using (DbContent db = new DbContent("mssql"))
{
var reader = db.Table("ttable").Read("cint", 10100, "cint", 20200);
reader.Dispose();
}
```
读取某个字段的值
```
using (DbContent db = new DbContent("mssql"))
{
var i = db.Table("ttable").ReadCell("cint", "pk", "11606");
}
```
查询某一列
```
using (DbContent db = new DbContent("mssql"))
{
var list = db.Table("ttable").ReadColumn("cstring", false, "cint", SqlOperator.GreaterThan, 202);
}
```
通过ActiveEntity执行
```
using (DbContent db = new DbContent("mssql"))
{
ActiveEntity ae = new ActiveEntity(db);
var list = ae.QueryByFields((x)=>x.PK, 11606);
}
```
通过lamda执行
```
using (DbContent db = new DbContent("mssql"))
{
ActiveEntity ae = new ActiveEntity(db);
var list = ae.Query((x) => x.CInt > 101 && x.CInt < 20200);
}
```
注意
==
要确保关闭DbConnection，特别是返回IDataReader时(此时DbContent不会自动关闭DbConnection)
FAQ
==
默认实体类型名字段名要和表名列名一致:
故意这么设计的，取不一样的名字有什么好处？ 当然也可以自定义映射关系
不追求性能:
不追求某一项的性能指标，加班到半夜和凌晨起来改bug和性能基本上没什么关系
不支持多表查询:
故意这么设计的， 如果有复杂的多表关联还是改掉为宜，或者用view
不支持缓存:
缓存不应该在数据层处理
不支持代码生成:
如果可以代码生成，就基本上可以统一处理
c#和golang对比
==
c#的优势:
* c#有泛型，写工具类代码很方便，golang只能用interface{}
* c#数据库支持很成熟，golang还差很多
golang的优势
* 无侵入的接口设计太人性化了
* 多返回值的设计比output参数更简洁明了, error的设计比try catch用起来更方便
* 类型系统比较灵活， 比如 type Procedure string，在c#就比较别扭
还有个差别和语言无关， golang没什么特别好用的编辑和调试工具，遇到bug只能先仔细读代码， c#遇到bug习惯先设断点单步调试，反而golang的调试时间少一点。
