Commits

March Liu committed f77a030

add some docs

  • Participants
  • Parent commits 3912da3

Comments (0)

Files changed (6)

File docs/pyCon2010/format.tex

+\usepackage{hyperref}
+\usepackage{makeidx}
+\usepackage{listings}
+
+\usepackage[boldfont,slantfont]{xeCJK}
+\usepackage{fontspec}
+\setCJKmainfont{文泉驿微米黑}
+
+%中文断行
+% \XeTeXlinebreaklocale "zh"
+% \XeTeXlinebreakskip = 0pt plus 1pt
+
+\usepackage{pstricks}
+\usepackage{pst-node}
+
+\pagestyle{headings}
+\makeindex
+\usepackage{color}
+\usepackage{fancyhdr}
+\pagestyle{fancy}
+% with this we ensure that the chapter and section
+% headings are in lowercase.
+\renewcommand{\chaptermark}[1]{\markboth{#1}{}}
+\renewcommand{\sectionmark}[1]{\markright{\thesection\ #1}}
+\fancyhf{} % delete current setting for header and footer
+\fancyhead[LE,RO]{\bfseries\thepage}
+\fancyhead[LO]{\bfseries\rightmark}
+\fancyhead[RE]{\bfseries\leftmark}
+\renewcommand{\headrulewidth}{0.5pt}
+\renewcommand{\footrulewidth}{0pt}
+\addtolength{\headheight}{0.5pt} % make space for the rule
+\fancypagestyle{plain}{%
+\fancyhead{} % get rid of headers on plain pages
+\renewcommand{\headrulewidth}{0pt} % and the line
+}
+
+\definecolor{listinggray}{gray}{0.9}
+

File docs/pyCon2010/introduction.tex

+\chapter{简介}
+
+\section{背景}
+
+在软件开发的经历中,关系型数据库给我带来了很大的便利。它提供了静态类型
+的强类型结构化存储方案。多种可选的竞争产品,带来了高度通用的信息管理能
+力,和各种优秀的特色功能。但是,在复杂多变的软件开发工作中,也体验到很
+多不便。
+
+\subsection{关系型数据库的问题}
+
+同一个表的所有记录必须拥有同一类型结构。虽然现代数据库产品出现了各种变
+通的表结构定义方式,如表继承等。但仍然脱离不了静态结构、强类型的范畴。
+
+类似游戏道具这样的数据,会有各种复杂的变体,往往会有一些特定的属性,如
+特效、镶嵌、附魔等,只有特定的一小部分物品有。而变化种类却非常多。通常
+说这是游戏的魅力所在,但是也使得数据存入关系型数据库有一定的困难。往往
+需要各种变通的手段。某些关系型数据库产品可能实现了此类稀疏矩阵的存储优
+化,但仍然需要一个很大的字段列表。需要添加新的字段时,如果记录比较多,
+性能非常糟糕,而且会产生很高级别的锁定。 \footnote{对于游戏,添加新
+  的,具有独特属性的物品是非常重要的升级内容。}
+
+关系数据库擅长以表为单位,根据定义式的SQL语句进行批量处理。或者定义表
+和表——即同构数据的集合间的关系。我们有时候会更希望针对某个独立的数据,
+操作它的值,或者处理关系。\footnote{现在流行的各种ORM对于解决此类问题
+  作出了很大贡献},特别是复杂的图结构,往往比较难用关系模 型描述。
+\footnote{多对多的节点-边定式在一定程度上解决了这个问题}。
+
+\subsection{动态数据结构的启发}
+
+在使用Delphi/C\#等静态语言几年后,我学到了 Python。这对我是一个非常非常
+大的震动和启发。由此我开始思考动态数据结构的持久化。我希望这种实现应该
+是一个真正的数据库方案,面向数据描述,适于检索,可以描述动态多变的数据
+结构和节点间关系。\footnote{相对而言,Python 内置的 pickle 更适合传输
+  以及小数据量的,面向单个对象的存储。}
+
+最直观的实现方法就是文本描述的字典,例如 JSON 就是一个非常好的切入点,
+但是 JSON 存储于关系型数据库时,往往只能作为文本,不能很方便的依据内容
+进行检索\footnote{在此推荐优秀的开源关系型数据库 PostgreSQL,它拥有
+  近乎无限的扩展能力。}。另一方面,节点之间的关系描述也不能说很方便。
+可以通过 URI 文本表达关联节点的位置,但是这需要应用层的解释。
+
+同样的问题也体现在 XML 上,XML 的标记属性功能使得它可以更方便的分离元
+信息与数据。但是这两种格式都不能有效的表达节点间关系描述,以及,在存储
+和使用非文本格式时,都不够高效。
+
+Key-value 数据库或许可以令我们想到字典,这是动态数据结构的最直观表示。
+但是 KV 数据库是与此非常不同的东西。每个存储节点本身成为一个巨大的字典。
+而不是我们期待的,大量小数据结构的统一管理。
+
+\subsection{三值逻辑}
+
+在中国的IT杂志《程序员》上读到一篇文章,标题为《屹立于关系数据库之上的
+语义网模型》。这篇文章启发了我,可以通过某种逻辑将原子数据关联起来。形
+成一种有层次的动态结构。经过一段时间的尝试以后,我建立了一种基于三元素
+结构的逻辑表达方式,Socrates 即是此三值逻辑体系的实现。
+
+Socrates 的逻辑体系有两个层次:条目和语句。每个条目是描述同一个主语的
+一组(主语,谓语,宾语)语句集合。
+
+\begin{figure}[htp]
+  \centering
+  \begin{pspicture}(0, 0)(7, 3)
+    \rput(0,1){\rnode{subject}{主语}}
+    \rput(4,0){\rnode{predicate0}{谓语}}
+    \rput(7,0){\rnode{object0}{宾语}}
+    \rput(4,1){\rnode{predicate1}{谓语}}
+    \rput(7,1){\rnode{object1}{宾语}}
+    \rput(4,2){\rnode{predicate2}{谓语}}
+    \rput(7,2){\rnode{object2}{宾语}}
+
+    \ncline{->}{subject}{predicate0}
+    \ncline{->}{predicate0}{object0}
+    \ncline{->}{subject}{predicate1}
+    \ncline{->}{predicate1}{object1}
+    \ncline{->}{subject}{predicate2}
+    \ncline{->}{predicate2}{object2}
+  \end{pspicture}
+  \caption{三值逻辑}
+\end{figure}
+

File docs/pyCon2010/others.tex

+\chapter{相关内容}
+
+动态数据结构的建模和数据库技术,已经有一些实现。例如
+\href{http://en.wikipedia.org/wiki/Entity-Attribute-Value_model}{EAV建
+  模技术}。已经类似XMLDB或JSON数据库等,都在不同程度上支持动态结构的数
+据管理。通常来说,使用的数据结构越灵活,管理活性能方面,就要作出更多的
+妥协。
+
+Socrates 的目标在于逐步建立一个尽可能方便可用的数据建模体系,在实践中
+寻找性能和可用性的平衡点。特别是在数据关系和动态结构上,尽可能的自然,
+而不失快捷。可以将 Socrates 理解为 EAV模型的一种强类型弱约束的实现。

File docs/pyCon2010/paper.tex

+\documentclass[unicode, a4paper]{book}
+
+\include{format}
+
+\begin{document}
+\title{三值逻辑与 Socrates 项目}
+\author{March Liu <march.liu@gmail.com>}
+\maketitle
+
+\tableofcontents
+
+\include{introduction}
+% \include{triplelogic}
+% \include{achieve}
+% \include{more}
+\include{others}
+% \include{thanks}
+\chapter{附录:索引}
+\printindex
+
+\end{document} 

File docs/zh20100314/slides.tex

+\documentclass[slidestop,compress]{beamer}
+%\usepackage[bars]{beamerthemetree} % Beamer Theme v 2.2
+\usetheme{JuanLesPins} % Beamer theme
+\usecolortheme{whale} % Beamer color theme
+
+\usepackage[boldfont,slantfont]{xeCJK}
+\usepackage{fontspec}
+\setCJKmainfont{文泉驿微米黑}
+
+\usepackage{color}
+\definecolor{listinggray}{gray}{0.9} 
+\usepackage{xcolor}
+
+\usepackage{pstricks}
+\usepackage{pst-node}
+\usepackage{pst-tree}
+
+\usepackage{listings}
+
+\title{Socrates 动态语义建模工具}
+\author[刘鑫]{刘鑫 <march.liu@gmail.com>}
+\institute{动态数据库建模与三值逻辑}
+
+\begin{document}
+
+\frame{\titlepage}
+
+\section{背景}
+\subsection{传统观点的RDB运用}
+%----------------------------------------------------------
+\begin{frame}
+\frametitle{关系型数据库(一)}
+库、表、字段、记录
+\begin{itemize}[<+-| alert@+>]
+\item 库是表的集合
+\item 通过字段集合定义表结构
+\item 同构的记录保存于同一个表中
+\end{itemize}
+\end{frame}
+%----------------------------------------------------------
+\begin{frame}
+\frametitle{关系型数据库(二)}
+传统的设计理念可以直接对应强类型静态语言
+\begin{itemize}[<+-| alert@+>]
+\item 程序包含类
+\item 类型定义由成员组成
+\item 对象结构由类型决定
+\end{itemize}
+\end{frame}
+%----------------------------------------------------------
+\subsection{问题与应对}
+\begin{frame}
+\frametitle{传统思路遇到的问题}
+所有静态强类型开发技术会遇到的问题
+\begin{itemize}[<+-| alert@+>]
+\item 随着程序运行,出现结构变更
+\item 快速开发过程,不断修改数据库结构
+\item 数据形成稀疏矩阵效应
+\end{itemize}
+\end{frame}
+%----------------------------------------------------------
+\begin{frame}
+\frametitle{动起来}
+
+我们该怎么做?
+\begin{itemize}[<+-| alert@+>]
+\item 用字典管理数据
+  \begin{itemize}
+  \item PG HStore
+  \item XML
+  \item JSON
+  \end{itemize}
+\item 动态语言
+  \begin{itemize}
+  \item EAV
+  \item 持久化DSL
+  \item Socrates
+  \end{itemize}
+\end{itemize}
+\end{frame}
+%----------------------------------------------------------
+\section{什么是Socrates?}
+\begin{frame}
+\frametitle{项目介绍}
+\url{http://bitbucket.org/March/socrates}
+\begin{itemize}[<+-| alert@+>]
+\item 基于三元语义的数据建模工具
+\item 面向关系型数据库的访问工具
+\item 针对动态数据结构实现
+\item 面向数据关系
+\end{itemize}
+\end{frame}
+%----------------------------------------------------------
+\subsection{三元语义与三值逻辑}
+\begin{frame}
+\frametitle{三元语义与三值逻辑}
+三元语义就是(主语,谓语,宾语)三元组
+\begin{itemize}[<+-| alert@+>]
+\item 每个宾语代表一个具体的数据
+\item 每个主语代表一个相关主题
+\item 谓语解释主语与宾语的关系
+\item 修改主题的结构,即增删子句
+\item 主题可以作为宾语
+\end{itemize}
+\end{frame}
+%----------------------------------------------------------
+\begin{frame}
+\frametitle{三值逻辑}
+三元语义的定义与划分
+\begin{itemize}[<+-| alert@+>]
+\item 用谓词表达结构
+\item 用宾语表达数据
+\item 元语义
+\end{itemize}
+\end{frame}
+%----------------------------------------------------------
+\subsection{ Socrates 实现}
+\begin{frame}
+\frametitle{动态语义实现}
+强类型动态类型工具
+\begin{itemize}[<+-| alert@+>]
+\item 基于 SQLAlchemy 实现
+\item 宾语可以是任何类型
+\item 可以书写为三值逻辑解释
+\item 类似字典的结构(持续改进中)
+\end{itemize}
+\end{frame}
+%----------------------------------------------------------
+\begin{frame}[containsverbatim,allowframebreaks]
+\frametitle{元语义}
+用三元语义解释三元语义
+\begin{itemize}
+ \item subject is type
+ \item predicate is subject
+ \item is is predicate
+ \item is objType subject
+ \item objType is predicate
+ \item objType objType subject
+ \item type is subject
+ \item string is type
+ \item name is predicate
+ \item name objType string
+ \item storage is predicate
+ \item storage objType string
+\end{itemize}
+\end{frame}
+%----------------------------------------------------------
+\begin{frame}[containsverbatim,allowframebreaks]
+\frametitle{实现目标}
+\begin{itemize}
+\item 使用 subject predicate object 解释数据
+\item 解决关系型数据库结构固定,不容易修改的问题
+\item 解决稀疏表的存储问题
+\item 建立于数据存储层之上,兼容不同类型的数据库
+\item 规则简单
+\item 元数据信息,自描述
+\item 结构开放,可以开发第三方接口
+\item 结构简单,基于递归和引用,容易使用
+\item 数据粒度小,伸缩性好,容易并发
+\item 可插入到其它体系中使用
+\end{itemize}
+\end{frame}
+%----------------------------------------------------------
+\begin{frame}[containsverbatim,allowframebreaks]
+\frametitle{已经实现的部分(一)}
+基于 SQLAlchemy 的智能存储接口 
+\begin{itemize}
+\item 自适应多种不同的数据库
+\item 构建架构
+\item 简单查询
+\item 支持简单的谓词表达式
+\item 类型动态注册和智能感知
+\end{itemize}
+\end{frame}
+%----------------------------------------------------------
+\begin{frame}[containsverbatim,allowframebreaks]
+\frametitle{已经实现的部分(二)}
+基于 SQLAlchemy 的智能数据对象
+\begin{itemize}
+\item object/objects
+\item 基于谓词的查询
+\item 数据维护
+\item 匹配 SQLAlchemy 成熟功能
+\item 可以直接使用 SQLAlchemy 已有的查询技术
+\end{itemize}
+\end{frame}
+%---------------------------------------------------------
+\section{展望}
+\subsection{近期}
+\begin{frame}
+\frametitle{近期目标}
+提高可用性
+\begin{itemize}[<+-| alert@+>]
+\item 子句对象字典化
+\item 理清容器行为逻辑
+\item 探索 URI 机制
+\item 优化查询性能
+\item 规范化谓词表达式
+\item 支持查询表达式和查询构建
+\end{itemize}
+\end{frame}
+%----------------------------------------------------------
+\subsection{中期}
+\begin{frame}
+\frametitle{中期目标}
+DSL
+\begin{itemize}[<+-| alert@+>]
+\item DSQL 初步
+\item SELECT *fields WHERE filters GROUP BY *columns ORDER BY *columns 
+\item UPDATE ... WHERE
+\item WRITE ... WHERE/NEW
+\end{itemize}
+\end{frame}
+%----------------------------------------------------------
+\subsection{长期目标}
+\begin{frame}
+\frametitle{长期目标}
+不靠谱的地平线
+\begin{description}[<+-| alert@+>]
+\item[EUCLID] 微观的 Socrates 内存数据结构组件
+\item[LIGHTING] 基于内存集群的非持久化高速三元语义引擎
+\item[PLATO] 基于 PostgreSQL 的原生动态引擎
+\item[UTOPIAN] 组合 Socrates 项目技术的三元语义EAV数据库
+\end{description}
+\end{frame}
+
+%----------------------------------------------------------
+\section{终}
+\begin{frame}
+\frametitle{感谢}
+谢谢大家在这里与我共度这次分享!
+\end{frame}
+\end{document}

File src/socrates/core.py

     """
     def __init__(self, uri=None, Session=None, create=False, schema=None, pool_size=20):
         """
-
+        
         """
         if uri:
             engine = create_engine(uri, pool_size=pool_size)
-            self.engine = engine
             self.Session = scoped_session(sessionmaker(bind=engine))
         elif Session:
-            self.Session = scoped_session(sessionmaker(bind=engine))
-            self.engine = self.Session
+            self.Session = Session
+            engine=Session.bind
+        else:
+            raise "paramater of uri or Session miss!" 
 
-        metadata = MetaData(bind=engine) 
+        self.engine = engine
+        metadata = MetaData(bind=self.engine) 
         self.sequence = Serial(engine, metadata, create=create, schema=schema)
         self.metadata = metadata 
         self.registed_type = {}