Updated: Delete works.

xql/driver.go

@@ -7,7 +7,7 @@ import (
 type StatementBuilder interface {
     Select(*Table, []QueryColumn, []QueryFilter, []QueryOrder, int64, int64) (string, []interface{}, error)
     Insert(*Table, interface{}, ...string) (string, []interface{}, error)
-    Update(*Table, []QueryFilter, ...interface{}) (string, []interface{}, error)
+    Update(*Table, []QueryFilter, interface{}) (string, []interface{}, error)
     Delete(*Table, []QueryFilter) (string, []interface{}, error)
 }
 

xql/driver/postgres/postgres.go

@@ -100,11 +100,46 @@ func (pb PostgresBuilder) Insert(t *xql.Table, obj interface{}, col...string) (s
     return
 }
 
-func (pb PostgresBuilder) Update(t *xql.Table, filters []xql.QueryFilter, objs ...interface{}) (s string, args []interface{}, err error) {
+func (pb PostgresBuilder) Update(t *xql.Table, filters []xql.QueryFilter, obj interface{}) (s string, args []interface{}, err error) {
+    s = "UPDATE "
+    if t.Schema != "" {
+        s += t.Schema+"."
+    }
+    s += t.TableName
+
     return
 }
 
 func (pb PostgresBuilder) Delete(t *xql.Table, filters []xql.QueryFilter) (s string, args []interface{}, err error) {
+    s = "DELETE FROM "
+    if t.Schema != "" {
+        s += t.Schema+"."
+    }
+    s += t.TableName
+    var n int
+    for i, f := range filters {
+        var cause string
+        switch f.Condition {
+        case xql.CONDITION_AND:
+            cause = "AND"
+        case xql.CONDITION_OR:
+            cause = "OR"
+        }
+        if i == 0 {
+            cause = "WHERE"
+        }
+        if f.Operator == "" {
+            s = fmt.Sprintf("%s %s %s", s, cause, f.Field)
+        } else if f.Reversed {
+            n += 1
+            s = fmt.Sprintf("%s %s $%d %s %s", s, cause, n, f.Operator, f.Field)
+            args = append(args, f.Value)
+        } else {
+            n += 1
+            s = fmt.Sprintf("%s %s %s %s $%d", s, cause, f.Field, f.Operator, n)
+            args = append(args, f.Value)
+        }
+    }
     return
 }
 

xql/query.go

@@ -13,12 +13,12 @@ type QueryColumn struct {
     Alias     string
 }
 
-func (qc QueryColumn) String() string {
+func (qc QueryColumn) String(as...bool) string {
     s := ""
     if qc.Function != "" {
         s = qc.Function+"("+qc.FieldName+")"
     }
-    if qc.Alias != "" {
+    if qc.Alias != "" && len(as)>0 && as[0] {
         s = s + " AS " + qc.Alias
     }
     return s
@@ -34,9 +34,55 @@ type QuerySet struct {
     limit   int64
 }
 
+type UpdateAssign struct {
+    Field string
+    Operator string
+    Value interface{}
+}
+
+type XRow struct {
+    row *sql.Row
+    qs *QuerySet
+}
+
+func (self *XRow) Scan(dest ...interface{}) error {
+    return self.row.Scan(dest...)
+}
+
+type XRows struct {
+    rows *sql.Rows
+    qs *QuerySet
+}
+
+func (self *XRows) Scan(dest ...interface{}) error {
+    if nil == self.rows {
+        return errors.New("No rows.")
+    }
+    return self.rows.Scan(dest...)
+}
+
+func (self *XRows) Next() bool {
+    if nil == self.rows {
+        return false
+    }
+    return self.rows.Next()
+}
+
+func (self *XRows) Close() {
+    self.rows.Close()
+    self.rows = nil
+}
+
 
 func makeQueryOrder(table *Table, s string) QueryOrder {
     qo := QueryOrder{}
+    if s[:1] == "-" {
+        qo.Type = ORDERTYPE_DESC
+        qo.Field = s[1:]
+    } else {
+        qo.Type = ORDERTYPE_ASC
+        qo.Field = s
+    }
     return qo
 }
 
@@ -101,20 +147,34 @@ func (self *QuerySet) Count(cols...string) (int64,error) {
     return n, nil
 }
 
-func (self *QuerySet) Next() bool {
-    return false
+func (self *QuerySet) All() (*XRows, error) {
+    s, args, err := self.session.getStatementBuilder().Select(self.table, self.queries,
+        self.filters, self.orders, self.offset, self.limit)
+    if nil != err {
+        return nil, err
+    }
+    rows, err := self.session.doQuery(s, args...)
+    if nil != err {
+        return nil, err
+    }
+    xrows := &XRows{rows:rows, qs:self}
+    return xrows, nil
 }
 
-func (self *QuerySet) Scan(vals ...interface{}) error {
-    return nil
-}
 
-func (self *QuerySet) One(vals ...interface{}) error {
-    return nil
+func (self *QuerySet) One() *XRow {
+    s, args, err := self.session.getStatementBuilder().Select(self.table, self.queries,
+        self.filters, self.orders, self.offset, 1)
+    if nil != err {
+        return nil
+    }
+    row := self.session.doQueryRow(s, args...)
+    xrow := &XRow{row:row, qs:self}
+    return xrow
 }
 
-func (self *QuerySet) Update(vals ...interface{}) (int64, error) {
-    s, args, err := self.session.getStatementBuilder().Update(self.table, self.filters, vals...)
+func (self *QuerySet) Update(vals interface{}) (int64, error) {
+    s, args, err := self.session.getStatementBuilder().Update(self.table, self.filters, vals)
     if nil != err {
         return 0, err
     }
@@ -129,14 +189,26 @@ func (self *QuerySet) Update(vals ...interface{}) (int64, error) {
     return 0, nil
 }
 
-func (self *QuerySet) Delete() error {
-    return nil
+func (self *QuerySet) Delete() (int64, error) {
+    s, args, err := self.session.getStatementBuilder().Delete(self.table, self.filters)
+    if nil != err {
+        return 0, err
+    }
+    var ret sql.Result
+    ret, err = self.session.doExec(s, args...)
+    if nil != err {
+        return 0, err
+    }else{
+        rows, e := ret.RowsAffected()
+        return rows, e
+    }
+    return 0, nil
 }
 
 func (self *QuerySet) Insert(objs ...interface{}) (int64, error) {
-    log.Debugln("Insert:> ", objs)
-    log.Debugln("Table:> ", self.table)
-    var ret sql.Result
+    //log.Debugln("Insert:> ", objs)
+    //log.Debugln("Table:> ", self.table)
+    //var ret sql.Result
     var rows int64 = 0
     var cols []string
     if len(self.queries) > 0 {
@@ -154,22 +226,22 @@ func (self *QuerySet) Insert(objs ...interface{}) (int64, error) {
         if nil != err {
             return 0, err
         }
-        ret, err = self.session.doExec(s, args...)
+        _, err = self.session.doExec(s, args...)
         if nil != err {
             return 0, err
         }else{
-            if nil != ret {
-                n, e := ret.LastInsertId()
-                if nil == e {
-                    rows += n
-                }else{
-                    rows += 1
-                }
-                log.Debugln("Insert:> ", n)
-            }else{
-                rows += 1
-            }
-
+            //if nil != ret {
+            //    n, e := ret.LastInsertId()
+            //    if nil == e {
+            //        rows += n
+            //    }else{
+            //        rows += 1
+            //    }
+            //    //log.Debugln("Insert:> ", n)
+            //}else{
+            //    rows += 1
+            //}
+            rows += 1
         }
     }
     return rows, nil