Updated sqobjects

Author: djthorpe

npm/sqlite3/html/index.html

@@ -38,11 +38,14 @@
                     <h1 class="_name">[schema]</h1>
                     <small class="_filename">[filename]</small>
                 </div>
+                <!-- NAV TABS -->
                 <ul class="nav nav-tabs" id="schema-table-list">
                     <li class="nav-item _template">
                         <a class="nav-link _name" aria-current="page" href="#">[table]</a>
                     </li>
                 </ul>
+                <!-- NAV TABS II -->
+                <nav-view class="nav-tabs" id="schema-table-nav"></nav-view>
                 <!-- TABLE CONTENT (TableView) -->
                 <div class="m-2">
                     <table-view cols="Col A, Col B, Col C"></table-view>

npm/sqlite3/js/controller/app.js

@@ -23,6 +23,9 @@ export default class App extends Controller {
   constructor() {
     super();
 
+    // Get nodes for the web components
+    const schemaTableNav = document.querySelector('#schema-table-nav');
+
     // VIEWS
     const navNode = document.querySelector('#nav');
     if (navNode) {
@@ -51,7 +54,6 @@ export default class App extends Controller {
     super.define('schemaview', new SchemaView(schemaNode));
     this.schemaview.addEventListener(['schema:change'], () => {
       console.log('schema:change');
-
       // Set active table to the first table in the schema
     });
     this.schemaview.addEventListener(['schema:click'], (sender, target) => {
@@ -108,6 +110,17 @@ export default class App extends Controller {
     this.schema.addEventListener(['provider:added', 'provider:changed'], (sender, schema) => {
       console.log(`schema added: ${schema}`);
       this.schemaview.schema = schema;
+      // Add the tabs
+      if (schemaTableNav) {
+        schema.tables.forEach((table) => {
+          const tab = document.createElement('nav-item-view');
+          tab.textContent = table.name;
+          tab.id = table.key;
+          tab.classList.add('nav-link');
+          schemaTableNav.appendChild(tab);
+        });
+        schemaTableNav.update();
+      }
     });
     this.schema.addEventListener('provider:deleted', (sender, schema) => {
       console.log(`schema deleted: ${schema}`);
@@ -120,6 +133,24 @@ export default class App extends Controller {
     this.tabledata.addEventListener(['provider:added', 'provider:changed'], (sender, data) => {
       console.log(`data added: ${data}`);
     });
+
+    // NEW STUFF    
+    if (schemaTableNav) {
+      schemaTableNav.addEventListener('nav-view:click', (evt) => {
+        // When click on a tab, make it active
+        schemaTableNav.active = evt.detail;
+      });
+      schemaTableNav.addEventListener('nav-view:active', (evt) => {
+        // Fire when the tab is active
+        console.log(`schema-table-nav active: ${evt.detail}`);
+      });
+      schemaTableNav.addEventListener('nav-view:deactive', (evt) => {
+        // Fire when the tab has been deactivated
+        console.log(`schema-table-nav deactive: ${evt.detail}`);
+        // Disconnect from parent
+        //schemaTableNav.removeChild(evt.detail);
+      });
+    }
   }
 
   main() {

npm/sqlite3/js/index.js

@@ -6,6 +6,9 @@ import '../css/index.css';
 import App from './controller/app';
 
 // Views
+import './view/nav-view';
+import './view/nav-item-view';
+
 import './view/table-view';
 import './view/table-head-view';
 import './view/table-body-view';

pkg/sqobj/sqclass.go

@@ -17,7 +17,7 @@ type Class struct {
 	SQSource
 
 	// Prepared statements and in-place parameters
-	s map[SQKey]SQStatement
+	s map[stkey]SQStatement
 	p []interface{}
 }
 
@@ -38,7 +38,7 @@ func MustRegisterClass(source SQSource, proto interface{}) *Class {
 // any errors
 func RegisterClass(source SQSource, proto interface{}) (*Class, error) {
 	this := new(Class)
-	this.s = make(map[SQKey]SQStatement)
+	this.s = make(map[stkey]SQStatement)
 
 	// Check name
 	if source.Name() == "" {
@@ -165,7 +165,7 @@ func (c *Class) Insert(txn SQTransaction, v ...interface{}) ([]int64, error) {
 		if !rv.IsValid() || rv.Type() != c.t {
 			return nil, ErrBadParameter.Withf("Insert: %v", v)
 		}
-		r, err := txn.Query(st, c.boundValues(rv, true)...)
+		r, err := txn.Query(st, c.boundValues(rv, true, false)...)
 		if err != nil {
 			return nil, err
 		}
@@ -244,24 +244,101 @@ func (c *Class) DeleteKeys(txn SQTransaction, v ...interface{}) (int, error) {
 	return n, nil
 }
 
+// Update objects by primary key, return number of updated rows
+func (c *Class) UpdateKeys(txn SQTransaction, v ...interface{}) (int, error) {
+	// Retrieve prepared statement
+	st, exists := c.s[SQKeyUpdateKeys]
+	if !exists {
+		return 0, ErrOutOfOrder.Withf("UpdateKeys: %q", c.Name())
+	}
+
+	// Update each object
+	var n int
+	for _, v := range v {
+		rv := ValueOf(v)
+		if !rv.IsValid() || rv.Type() != c.t {
+			return 0, ErrBadParameter.Withf("UpdateKeys: %v", v)
+		}
+		r, err := txn.Query(st, c.boundValues(rv, false, true)...)
+		if err != nil {
+			return 0, err
+		}
+		n += r.RowsAffected()
+	}
+
+	// Return success
+	return n, nil
+}
+
+func (c *Class) UpsertKeys(txn SQTransaction, v ...interface{}) ([]int64, error) {
+	result := make([]int64, 0, len(v))
+
+	// Retrieve prepared statement
+	st, exists := c.s[SQKeyUpsertKeys]
+	if !exists {
+		return nil, ErrOutOfOrder.Withf("UpdateKeys: %q", c.Name())
+	}
+
+	// Update each object
+	for _, v := range v {
+		rv := ValueOf(v)
+		if !rv.IsValid() || rv.Type() != c.t {
+			return nil, ErrBadParameter.Withf("UpdateKeys: %v", v)
+		}
+		r, err := txn.Query(st, c.boundValues(rv, true, false)...)
+		if err != nil {
+			return nil, err
+		}
+		if r.RowsAffected() > 0 {
+			if r.LastInsertId() == 0 {
+				fmt.Println("TODO: Set last insert id as rows affected (was an update)")
+				result = append(result, -1)
+			} else {
+				result = append(result, r.LastInsertId())
+			}
+		} else {
+			result = append(result, 0)
+		}
+	}
+
+	// Return success
+	return result, nil
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // PRIVATE METHODS
 
 // boundValues returns sqlite-compatible values for a struct value. If autonull
 // argument is true, then any zero-value column is set to NULL. This is so inserts
-// can be performed.
-func (this *Class) boundValues(v reflect.Value, autonull bool) []interface{} {
+// can be performed. If primarylast is true, then primary values are put behind non-
+// primary values.
+func (this *Class) boundValues(v reflect.Value, autonull bool, primarylast bool) []interface{} {
 	// Set length of parameters
 	this.p = this.p[:len(this.col)]
 
-	// Iterate over columns
-	for i, col := range this.col {
+	// First iteration sets values
+	j := 0
+	if primarylast {
+		for _, col := range this.col {
+			field := v.Field(col.Field.Index)
+			if !col.Primary {
+				this.p[j] = field.Interface()
+				j++
+			}
+		}
+	}
+
+	for _, col := range this.col {
 		field := v.Field(col.Field.Index)
+		if primarylast && !col.Primary {
+			continue
+		}
 		if autonull && col.Auto && field.IsZero() {
-			this.p[i] = nil
+			this.p[j] = nil
 		} else {
-			this.p[i] = field.Interface()
+			this.p[j] = field.Interface()
 		}
+		j++
 	}
 
 	// Return success

pkg/sqobj/sqclass_statements.go

@@ -11,16 +11,30 @@ import (
 // TYPES
 
 type sqpreparefunc func(*Class, SQTransaction) SQStatement
+type stkey uint
 
 ///////////////////////////////////////////////////////////////////////////////
 // GLOBALS
 
+const (
+	SQKeyNone stkey = iota
+	SQKeySelect
+	SQKeyInsert
+	SQKeyDeleteRows
+	SQKeyDeleteKeys
+	SQKeyUpdateKeys
+	SQKeyUpsertKeys
+	SQKeyMax = SQKeyUpdateKeys
+)
+
 var (
-	statements = map[SQKey]sqpreparefunc{
+	statements = map[stkey]sqpreparefunc{
 		SQKeySelect:     sqSelect,
 		SQKeyInsert:     sqInsert,
 		SQKeyDeleteRows: sqDeleteRows,
 		SQKeyDeleteKeys: sqDeleteKeys,
+		SQKeyUpdateKeys: sqUpdateKeys,
+		SQKeyUpsertKeys: sqUpsertKeys,
 	}
 )
 
@@ -59,99 +73,27 @@ func sqDeleteKeys(class *Class, _ SQTransaction) SQStatement {
 	return class.SQSource.Delete(cols...)
 }
 
-/*
-
-func (this *sqclass) addStatements(flags SQFlag) error {
-	this.RWMutex.Lock()
-	defer this.RWMutex.Unlock()
-
-	// Create statments for create,insert and delete
-	this.addStatement(SQKeyCreate, this.sqCreate())
-	this.addStatement(SQKeyWrite, this.sqInsert(flags))
-	this.addStatement(SQKeyRead, this.sqSelect())
-
-	// If we have primary keys, other operations are possible
-	if len(this.PrimaryColumnNames()) > 0 {
-		this.addStatement(SQKeyDelete, this.sqDelete())
-		this.addStatement(SQKeyGetRowId, this.sqGetRowId())
-	}
-
-	// Create index statements
-	for _, index := range this.indexes {
-		this.addStatement(SQKeyCreate, this.sqIndex(index))
-	}
-
-	// Return success
-	return nil
-}
-
-func (this *sqclass) addStatement(key SQKey, st SQStatement) {
-	this.s[key] = append(this.s[key], st)
-}
-
-func (this *sqclass) sqCreate() SQTable {
-	st := this.CreateTable(this.Columns()...).IfNotExists()
-	for _, column := range this.columns {
-		if column.Unique {
-			st = st.WithUnique(column.Field.Name)
-		} else if column.Index {
-			st = st.WithIndex(column.Field.Name)
+func sqUpdateKeys(class *Class, _ SQTransaction) SQStatement {
+	values := make([]string, 0, len(class.col))
+	keys := make([]interface{}, 0, len(class.col))
+	for _, c := range class.col {
+		if !c.Primary {
+			values = append(values, c.Col.Name())
+		} else {
+			keys = append(keys, Q(N(c.Col.Name()), "=", P))
 		}
 	}
-	return st
-}
-
-func (this *sqclass) sqIndex(index *sqindex) SQStatement {
-	st := N(this.Name()+"_"+index.name).
-		WithSchema(this.Schema()).
-		CreateIndex(this.Name(), index.cols...).IfNotExists()
-	if index.unique {
-		st = st.WithUnique()
-	}
-	return st
+	return class.SQSource.Update(values...).Where(keys...)
 }
 
-func (this *sqclass) sqInsert(flags SQFlag) SQStatement {
-	st := this.Insert(this.ColumnNames()...)
-
-	// Add conflict resolution for any primary key field
-	st = st.WithConflictUpdate(this.PrimaryColumnNames()...)
-
-	// Add conflict resolution for any unique fields
-	for _, column := range this.columns {
-		if column.Unique && flags&SQLITE_FLAG_UPDATEONINSERT != 0 {
-			st = st.WithConflictUpdate(column.Field.Name)
-		}
-	}
-
-	// Add conflict for any unique indexes
-	for _, index := range this.indexes {
-		if index.unique && flags&SQLITE_FLAG_UPDATEONINSERT != 0 {
-			st = st.WithConflictUpdate(index.cols...)
+func sqUpsertKeys(class *Class, _ SQTransaction) SQStatement {
+	cols := make([]string, len(class.col))
+	keys := make([]string, 0, len(class.col))
+	for i, col := range class.col {
+		cols[i] = col.Col.Name()
+		if col.Primary {
+			keys = append(keys, col.Col.Name())
 		}
 	}
-
-	// Return success
-	return st
-}
-
-func (this *sqclass) sqDelete() SQStatement {
-	expr := []interface{}{}
-	for _, name := range this.PrimaryColumnNames() {
-		expr = append(expr, Q(N(name), "=", P))
-	}
-	return this.Delete(expr...)
-}
-
-func (this *sqclass) sqGetRowId() SQStatement {
-	expr := []interface{}{}
-	for _, name := range this.PrimaryColumnNames() {
-		expr = append(expr, Q(N(name), "=", P))
-	}
-	return S(this.SQSource).To(N("rowid")).Where(expr...)
-}
-
-func (this *sqclass) sqSelect() SQStatement {
-	return S(this.SQSource).To(this.ColumnSources()...)
+	return class.SQSource.Insert(cols...).WithConflictUpdate(keys...)
 }
-*/