Commits

March Liu  committed 1e0f464

add array predicates; nometa subject id start 100; add integer type

  • Participants
  • Parent commits 731342e

Comments (0)

Files changed (7)

File .DS_Store

Binary file modified.

File docs/.DS_Store

Binary file modified.

File docs/CPGM2011/SocratesOnPG.pdf

Binary file modified.

File docs/CPGM2011/SocratesOnPG.tex

 \item name is predicate
 \item name objType string
 \item string is type
+\item uri is predicate
+\item uri objType string
+\item arrayOf is predicate
+\item arrayOf objType subject
+\item arrayIndex is predicate
+\item arraryIndex objType integer
+\item arrayNext is predicate
+\item arrayNext objType subject
 \end{itemize}
 
 \subsubsection{元语释义}
 \item is 的 objType 是 subject(即它将指向一个subject id 或 subject link)。
 \item name 是谓词,objType 为 string。
 \item string 是一个 type,是基础数据类型。对于 PostgreSQL ,对应的是 TEXT。
+\item uri 表示这个 subject 是一个代理类,它实际指向一个远程的 subject
+\item arrayOf 表示这个 subject 是一个序列容器的子项,它指向的容器可以
+  是任意的subject
+\item arrayIndex 表示一个容器子项的位置索引,arrayNext 表示当前子项的
+  下一项,两者只需要出现一个就可以,但是不能都没有。
 \end{itemize}
 
 \subsubsection{退化的隐含元语}
 
 Socrates 是面向字典型数据条目设计的,它不便于表达线性序列。如何构造一
 个高效的线性序列表达,还在思考中。目前对于规模不大的线性序列,可以使用
-JSON 文本或 PostgreSQL 的数组类型。
+JSON 文本或 PostgreSQL 的数组类型。在语义上,arrayOf已经可以表达线性容
+器,但是这部分的应用层代码还没有完成。
+
+数值计算时一个著名的问题是整数和实数的隐式转型,这个在socrates中是一个
+待实现的功能。
+
+URI 的语义设计刚刚完成,这个谓词还没有实现。它的作用是实现一个远程代理。
+访问当前subject,实际上是访问远程的数据链接。
 
 \subsection{一些构想}
 

File docs/CPGM2011/slideOf.tex

+\documentclass[utf8x, notes=hide]{beamer}
+%\usepackage[bars]{beamerthemetree} % Beamer Theme v 2.2
+% \usetheme{JuanLesPins} % Beamer theme
+\usetheme{boxes} % Beamer theme
+\usecolortheme{whale} % Beamer color theme
+
+\usepackage[boldfont,slantfont]{xeCJK}
+\usepackage{fontspec}
+\setmainfont{Times New Roman}
+\setsansfont{Helvetica}
+\setmonofont{Monaco}
+\setCJKmainfont{文泉驿正黑}
+\setCJKsansfont{文泉驿微米黑}
+\setCJKmonofont{WenQuanYi Micro Hei Mono}
+\setCJKfamilyfont{tt}{Monaco}
+
+%中文断行
+\XeTeXlinebreaklocale "zh"
+\XeTeXlinebreakskip = 0pt plus 1pt
+\usepackage{color}
+\definecolor{listinggray}{gray}{0.9} 
+\usepackage{xcolor}
+
+\usepackage{listings}
+\lstset{language=sql,
+%numbers=left,
+backgroundcolor=\color{listinggray},
+showspaces=false,
+showstringspaces=false,
+basicstyle=\ttfamily, 
+frame=single,
+%framexleftmargin=7mm,
+frameshape={RYN}{y}{y}{RYN}}
+\usepackage{hyperref}
+
+\title{Socrates 动态建模工具}
+\author[刘鑫]{March Liu <march.liu@gmail.com>}
+\institute{理论及Python + PostgreSQL 实现}
+
+\begin{document}
+
+\begin{frame}
+ \titlepage
+\end{frame}
+
+\section{什么是Socrates?}
+
+\begin{frame}
+  \begin{center}
+    \Huge{什么是 Socrates?}
+  \end{center}
+\end{frame}
+
+\begin{frame}
+  \begin{center}
+     动态建模设计
+  \end{center}
+\end{frame}
+
+\begin{frame}
+  \begin{center}
+用一套数据库结构自适应任意数据结构
+  \end{center}
+\end{frame}
+
+\begin{frame}
+  \begin{center}
+可扩展,可适应未知类型
+  \end{center}
+\end{frame}
+
+\begin{frame}
+  \begin{center}
+自解读,不需要额外的辅助信息,可以从数据库中得到完整的信息内容和结构。
+  \end{center}
+\end{frame}
+
+\subsection{理论基础}
+
+\begin{frame} 
+\frametitle{三元结构}
+  \begin{itemize}  [<+-| alert@+> ]
+  \item Socrates的原子结构称为subject(条目/主语)。这是一个map数据结构
+  \item 每个subject有内部的精细结构,由一组三元短语描述,称为 segment
+  \item 三元短语结构为 (subject, predicate, object)
+  \item predicate ,即谓词,表示subject的内部结构,即字典的key
+  \item object,即宾语,指 subject 由谓词表达的值,即字典的value
+  \end{itemize}
+\end{frame}
+
+\begin{frame}
+  \frametitle{主语 Subject}
+  在语义上,主语 subject 表示一组相关子句的集合。在实现上,subject是一
+  个匿名的字典。存储于数据库中的时候,由数据库维护其id,但是通常用户并
+  不需要直接关心其id,而是在应用层通过变量使用它。
+\end{frame}
+
+\begin{frame}
+  \frametitle{谓语 Predicate}
+谓词在应用层取出的subject中,就是字典的key。在数据库中,它表示
+subject所具有的内部结构。每个predicate必须有自己的名字,需要标的自己的
+宾语类型,即 obType。根据objType,可以得到宾语存储的位置。(未来可能改
+变)
+\end{frame}
+
+\begin{frame}
+  \frametitle{宾语 object}
+  宾语是实际的值,它可能有任何类型,Socrates 只要求最少实现三种类型:基
+  本的 string 和 subject(实际上是integer或string),和integer(如果不考
+  虑array支持,可以不包含integer)。
+\end{frame}
+
+\section{Socrates 语义}
+
+\begin{frame}
+  \begin{center}
+    \Huge{语义设计}
+  \end{center}
+\end{frame}
+
+\begin{frame}[allowframebreaks]
+  \frametitle{META SEGMENTS}
+为了实现自解释,Socrates 系统包含一组元语义:
+
+\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
+\item uri is predicate
+\item uri objType string
+\end{itemize}
+
+\end{frame}
+
+\subsection{自解释实例}
+
+\begin{frame}
+  \frametitle{示例}
+  通过前面的元语定义,我们可以做到信息自解释。例如,一个人员信
+  息条目可能是:
+
+$$
+subject = \begin{cases}
+user name, & "March Liu" \\
+mail,  & "march.liu@gmail.com" \\
+...
+\end{cases}
+$$
+
+\end{frame}
+
+\begin{frame}
+  \frametitle{user name}
+
+其中 username 谓词:
+
+$$
+username = \begin{cases}
+is, & predicate \\
+name , & "user name" \\
+objType,  & "string" \\
+\end{cases}
+$$
+\end{frame}
+
+\begin{frame}
+  \frametitle{mail}
+
+mail 谓词:
+
+$$
+mail = \begin{cases}
+is, & predicate \\
+name , & "mail" \\
+objType,  & string \\
+\end{cases}
+$$
+\end{frame}
+
+\begin{frame}
+  \frametitle{Predicate 也是subject}
+
+这里两次出现的 (objType, string),是一条segment, 说明 predicate 的宾
+语类型。 类型 string 本身也是一个 subject 
+
+$$
+string = \begin{cases}
+name , & "string" \\
+stroage ,  & "segment_string" \\
+\end{cases}
+$$
+
+至此,已经完全进入到了原语定义范畴,不需要再递归解释了。
+
+\end{frame}
+
+\begin{frame}
+  \frametitle{}
+\end{frame}
+
+\section{Python + PostgreSQL 实现}
+
+\begin{frame}
+  \begin{center}
+    \Huge{已实现的功能}
+  \end{center}
+\end{frame}
+
+\begin{frame}
+  \begin{center}
+  \huge{Python + SQLAlchemy}
+  \end{center}
+\end{frame}
+
+\begin{frame}
+  \begin{center}
+    SQLite + PostgreSQL
+  \end{center}
+\end{frame}
+
+\begin{frame}
+  \begin{center}
+     TDD,测试即文档
+  \end{center}
+\end{frame}
+
+\begin{frame}
+  \begin{center}
+      通过所有测试(暂时不包括array)
+  \end{center}
+\end{frame}
+
+\begin{frame}
+  \begin{center}
+      初级的dsl表达式支持
+  \end{center}
+\end{frame}
+
+\begin{frame}
+  \begin{center}
+      \huge{postgreSQL plpgsql}
+  \end{center}
+\end{frame}
+
+\begin{frame}
+  \begin{center}
+初步的segment读写
+  \end{center}
+\end{frame}
+
+\begin{frame}
+  \begin{center}
+一些常用的谓词操作
+  \end{center}
+\end{frame}
+
+\section{缺陷、构想和待实现的功能}
+
+\begin{frame}
+  \begin{center}
+    \Huge{缺陷、构想和待实现的功能}
+  \end{center}
+\end{frame}
+
+\begin{frame}
+  \begin{center}
+DSL
+  \end{center}
+\end{frame}
+
+\begin{frame}
+  \begin{center}
+性能优化
+  \end{center}
+\end{frame}
+
+\begin{frame}
+  \begin{center}
+动态类型
+  \end{center}
+\end{frame}
+
+\begin{frame}
+  \begin{center}
+其它语言的实现
+  \end{center}
+\end{frame}
+
+\begin{frame}
+\frametitle{正在实现}
+  \begin{center}
+基于objective c和sqlite的定制ios嵌入版
+  \end{center}
+\end{frame}
+
+\section{结束}
+
+\begin{frame}
+  \begin{center}
+\Huge{谢谢大家,再见!}
+  \end{center}
+ \rightline{\~{} Power By \LaTeX{}}
+\end{frame}
+
+\end{document}

File src/socrates/core.py

 #! /usr/bin/evn python
 # -*- coding:utf-8 -*-
 
+import logging
+
 from sqlalchemy import create_engine, MetaData, Sequence, Table, Column, String, select, join, Integer, and_
 from sqlalchemy.orm import sessionmaker, scoped_session, mapper
 import meta
     """
 >>> storage = Storage("sqlite://", create=True)
 >>> storage.registed_type.keys()
-['string', 'subject']
+['integer', 'string', 'subject']
     """
     def __init__(self, uri=None, Session=None, create=False, schema=None, pool_size=20):
         """
             self.initStorage(schema=schema)
         else:
             subject_table = Table('segment_subject', metadata, 
-                                  Column('subject_id', Integer, index=True, default=self.sequence,), 
+                                  Column('subject_id', Integer, primary_key=True),
+                                  Column('predicate_id', Integer, primary_key=True), 
                                   autoload=True, schema=schema)
             string_table = Table('segment_string', metadata, 
-                                 Column('subject_id', Integer, index=True, default=self.sequence,),
+                                 Column('subject_id', Integer, primary_key=True),
+                                 Column('predicate_id', Integer, primary_key=True),
                                  autoload=True, schema=schema)
+            integer_table = Table('segment_integer', metadata, 
+                                  Column('subject_id', Integer, primary_key=True),
+                                  Column('predicate_id', Integer, primary_key=True),
+                                 autoload=True, schema=schema)
+            
             self.registed_type['subject'] = self.__make_type_helper('subject', subject_table)
             self.registed_type['string'] = self.__make_type_helper('string', string_table)
+            self.registed_type['integer'] = self.__make_type_helper('integer', integer_table)
             self.registed_storage['subject'] = subject_table
             self.registed_storage['string'] = string_table
+            self.registed_storage['integer'] = integer_table
+            
             names = string_table.alias('names')
             storages = string_table.alias('storage')
 
 >>> retype.table.name
 'segment_datetime'
 >>> storage.registed_type.keys()
-['datetime', 'string', 'subject']
+['integer', 'datetime', 'string', 'subject']
         """
         if storage:
             storname = storage
 >>> retype = storage.registeType("datetime", colType=DateTime, create=True)
 >>> pid = storage.newPredicate("when", "datetime")
 >>> print pid
-11
+102
 >>> when = storage.getSubjectById(pid)
 >>> print when.subject_id==pid
 True
 500
 >>> sid = storage.writeSubject(None, {'ssoid':'nobody'})
 >>> print sid
-11
-        """
+102
+"""
         if subject_id:
             sid = subject_id
         else:
 >>> pid = storage.newPredicate('ssoid', 'string')
 >>> segment = storage.writeSegment(500, 'ssoid', 'liuxin2')
 >>> print segment.subject_id, segment.predicate_id
-500 11
+500 102
 >>> print segment.subject_id
 500
 >>> segment = storage.writeSegment(None, 'ssoid', 'nobody')
 >>> print segment.obj
 nobody
 >>> print segment.subject_id
-12
+103
         """
         pname, tnames = self.parsePredicateExpression(predicateExpr)
         if len(tnames)>1:
         else:
             string = Column('obj', String(8000))
 
-        table = Table('segment_string', self.metadata,
+        string_table = Table('segment_string', self.metadata,
                       Column('subject_id', Integer, default=self.sequence, primary_key=True),
                       Column('predicate_id', Integer, primary_key=True),
                       string,
                       schema=schname)
-        
-        table.create()
-        self.registed_type["string"] = self.__make_type_helper("string", table)
-        self.registed_storage["string"]=table
+        string_table.create()
+        integer_table = Table('segment_integer', self.metadata,
+                      Column('subject_id', Integer, default=self.sequence, primary_key=True),
+                      Column('predicate_id', Integer, primary_key=True),
+                      Column('obj', Integer),
+                      schema=schname)
+        integer_table.create()
+        self.registed_type["string"] = self.__make_type_helper("string", string_table)
+        self.registed_storage["string"]=string_table
+        self.registed_type["integer"] = self.__make_type_helper("integer", integer_table)
+        self.registed_storage["integer"]=integer_table
 
         self.initMetadata()
 
     def initMetadata(self, clearfirst=False):
         meta.init_meta(self.engine, self.registed_storage["subject"], 
-                       self.registed_storage["string"], self.sequence, clearfirst)
+                       self.registed_storage["string"],
+                       self.registed_storage["integer"],
+                       self.sequence, clearfirst)
 
     def getSegmentsBySubjectId(self, subject_id, autocommit=False):
         for Type in self.registed_type.values():
 >>> storage = Storage("sqlite://", create=True)
 >>> pid = storage.newPredicate('ssoid', 'string')
 >>> print pid
-10
+101
 >>> ssoid = storage.getSubjectById(pid)
 >>> print ssoid.name
 ssoid
 >>> storage = Storage("sqlite://", create=True)
 >>> pid = storage.newPredicate('ssoid', 'string')
 >>> print pid
-10
+101
 >>> ssoid = storage.getSubjectById(pid)
 >>> print ssoid.name
 ssoid
         session = self.Session()
         objType = session.query(sgsbj.obj).filter(sgsbj.subject_id==pid).filter(sgsbj.predicate_id==meta.OBJTYPE).scalar()
         stname = session.query(sgstr.obj).filter(sgstr.subject_id==objType).filter(sgstr.predicate_id==meta.NAME).scalar()
+        
         table = self.registed_storage[stname]
         return session.query(table).filter(table.c.subject_id==sid).filter(table.c.predicate_id==pid).first()
 
-
     def __make_type_helper(self, typename, table):
         def setSubject(_self, subject):
             _self.obj = subject.subject_id

File src/socrates/meta.py

  - objType 定义谓词的客体类型
  - objType 是谓词的隐式定义内容
  - name objType string ,所以 string 语义表是基础组件,要与relation一起预建
+ - arrayOf 定义 subject 是一个线性容器的一部分
+ - arrayIndex  定义该 subject 在线性容器中的索引
+ - arrayNext 定义该 subject 所属线性容器的下一个节点
 
 ** relation
 
  - storage objType string
  - uri is predicate
  - uri objType string
+ - arrayOf is predicate
+ - arrayOf objType subject
+ - arrayIndex is predicate
+ - arrayIndex objType integer
+ - arrayNext is predicate
+ - arrayNext objType subject
+ 
 ** 常量定义
 
 """
 OBJTYPE = 4
 TYPE = 5
 STRING = 6
-NAME = 7
-URI = 8
-STORAGE = 9
+INTEGER = 7
+NAME = 8
+URI = 9
+STORAGE = 10
+ARRAYOF = 11
+ARRAYINDEX = 12
+ARRAYNEXT = 13
 
-def init_meta(engine, subjects, strings, sequence, clearfirst=False):
+def init_meta(engine, subjects, strings, integers, sequence, clearfirst=False):
     from sqlalchemy.orm import sessionmaker
     session = sessionmaker(bind=engine)()
     #conn = session.connection()
         session.execute(strings.delete())
         session.execute(subjects.delete())
 
-    for i in range(9):
+    for i in range(13):
         session.execute(subjects.insert().values(subject_id=sequence(), predicate_id=1))
     session.flush()
 
+    #预留的id
+    for i in range(87):
+        sequence()
+    session.flush()
+
     update(SUBJECT, SUBJECT, IS, TYPE)
     name(SUBJECT, 'subject')
     storage(SUBJECT, 'segment_subject')
     name(STRING, 'string')
     storage(STRING, 'segment_string')
 
+    update(INTEGER, INTEGER, IS, TYPE)
+    name(INTEGER, 'integer')
+    storage(INTEGER, 'segment_integer')
+
     update(NAME, NAME, IS, PREDICATE)
     name(NAME, 'name')
     insert(NAME, OBJTYPE, STRING)
     name(STORAGE, 'storage')
     insert(STORAGE, OBJTYPE, STRING)
 
+    update(ARRAYOF, ARRAYOF, IS, PREDICATE)
+    name(ARRAYOF, 'arrayOf')
+    insert(ARRAYOF, OBJTYPE, SUBJECT)
+
+    update(ARRAYINDEX, ARRAYINDEX, IS, PREDICATE)
+    name(ARRAYINDEX, 'arrayIndex')
+    insert(ARRAYINDEX, OBJTYPE, INTEGER)
+
+    update(ARRAYNEXT, ARRAYNEXT, IS, PREDICATE)
+    name(ARRAYNEXT, 'arrayNext')
+    insert(ARRAYNEXT, OBJTYPE, SUBJECT)
+
     session.commit()
     session.close()