WIP 1

Author: BrandonRoehl

dump.go

@@ -33,9 +33,13 @@ type Data struct {
 }
 
 type table struct {
-	Name   string
-	SQL    string
-	Values []string
+	Name string
+	Err  error
+
+	data   *Data
+	rows   *sql.Rows
+	types  []reflect.Type
+	values []interface{}
 }
 
 type metaData struct {
@@ -68,22 +72,22 @@ const tableTmpl = `
 -- Table structure for table {{ .Name }}
 --
 
-DROP TABLE IF EXISTS {{ .Name }};
+DROP TABLE IF EXISTS {{ .NameEsc }};
 /*!40101 SET @saved_cs_client     = @@character_set_client */;
  SET character_set_client = utf8mb4 ;
-{{ .SQL }};
+{{ .CreateSQL }};
 /*!40101 SET character_set_client = @saved_cs_client */;
 
 --
 -- Dumping data for table {{ .Name }}
 --
 
-LOCK TABLES {{ .Name }} WRITE;
+LOCK TABLES {{ .NameEsc }} WRITE;
 /*!40000 ALTER TABLE {{ .Name }} DISABLE KEYS */;
 {{- if .Values }}
 INSERT INTO {{ .Name }} VALUES
-{{- range $index, $element := .Values -}}
-{{- if $index }},{{ else }} {{ end -}}{{ $element }}
+{{- range .Next -}}
+, {{ end -}}{{ .RowValues }}
 {{- end -}};
 {{- end }}
 /*!40000 ALTER TABLE {{ .Name }} ENABLE KEYS */;
@@ -237,112 +241,128 @@ func (data *metaData) updateServerVersion(db *sql.DB) (err error) {
 // MARK: create methods
 
 func (data *Data) createTable(name string) (*table, error) {
-	var err error
-	t := &table{Name: "`" + name + "`"}
-
-	if t.SQL, err = data.createTableSQL(name); err != nil {
-		return nil, err
-	}
-
-	if t.Values, err = data.createTableValues(name); err != nil {
-		return nil, err
+	t := &table{
+		Name: name,
+		data: data,
 	}
 
 	return t, nil
 }
 
-func (data *Data) createTableSQL(name string) (string, error) {
+func (table *table) NameEsc() string {
+	return "`" + table.Name + "`"
+}
+
+func (table *table) CreateSQL() (string, error) {
 	var tableReturn, tableSQL sql.NullString
-	err := data.Connection.QueryRow("SHOW CREATE TABLE `"+name+"`").Scan(&tableReturn, &tableSQL)
+	err := table.data.Connection.QueryRow("SHOW CREATE TABLE "+table.NameEsc()).Scan(&tableReturn, &tableSQL)
 
 	if err != nil {
 		return "", err
 	}
-	if tableReturn.String != name {
+	if tableReturn.String != table.Name {
 		return "", errors.New("Returned table is not the same as requested table")
 	}
 
 	return tableSQL.String, nil
 }
 
-func (data *Data) createTableValues(name string) ([]string, error) {
-	rows, err := data.Connection.Query("SELECT * FROM `" + name + "`")
+// defer rows.Close()
+func (table *table) Init() (err error) {
+	if len(table.types) != 0 {
+		return errors.New("can't init twice")
+	}
+
+	table.rows, err = table.data.Connection.Query("SELECT * FROM " + table.NameEsc())
 	if err != nil {
-		return nil, err
+		return err
 	}
-	defer rows.Close()
 
-	columns, err := rows.Columns()
+	columns, err := table.rows.Columns()
 	if err != nil {
-		return nil, err
+		return err
 	}
 	if len(columns) == 0 {
-		return nil, errors.New("No columns in table " + name + ".")
+		return errors.New("No columns in table " + table.Name + ".")
 	}
 
-	dataText := make([]string, 0)
-	tt, err := rows.ColumnTypes()
+	tt, err := table.rows.ColumnTypes()
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	types := make([]reflect.Type, len(tt))
+	table.types = make([]reflect.Type, len(tt))
 	for i, tp := range tt {
 		st := tp.ScanType()
 		if tp.DatabaseTypeName() == "BLOB" {
-			types[i] = reflect.TypeOf(sql.RawBytes{})
+			table.types[i] = reflect.TypeOf(sql.RawBytes{})
 		} else if st != nil && (st.Kind() == reflect.Int ||
 			st.Kind() == reflect.Int8 ||
 			st.Kind() == reflect.Int16 ||
 			st.Kind() == reflect.Int32 ||
 			st.Kind() == reflect.Int64) {
-			types[i] = reflect.TypeOf(sql.NullInt64{})
+			table.types[i] = reflect.TypeOf(sql.NullInt64{})
 		} else {
-			types[i] = reflect.TypeOf(sql.NullString{})
+			table.types[i] = reflect.TypeOf(sql.NullString{})
 		}
 	}
-	values := make([]interface{}, len(tt))
-	for i := range values {
-		values[i] = reflect.New(types[i]).Interface()
+	table.values = make([]interface{}, len(tt))
+	for i := range table.values {
+		table.values[i] = reflect.New(table.types[i]).Interface()
 	}
-	for rows.Next() {
-		if err := rows.Scan(values...); err != nil {
-			return dataText, err
+	return nil
+}
+
+func (table *table) Next() bool {
+	if table.rows == nil {
+		if err := table.Init(); err != nil {
+			table.Err = err
+			return false
+		}
+	} else if table.rows.Next() {
+		if err := table.rows.Scan(table.values...); err != nil {
+			table.Err = err
+			return false
 		}
+	} else {
+		table.rows.Close()
+		table.rows = nil
+		return false
+	}
+	return true
+}
+
+func (table *table) RowValues() (string, error) {
+	dataStrings := make([]string, len(table.values))
 
-		dataStrings := make([]string, len(columns))
-
-		for key, value := range values {
-			if value == nil {
-				dataStrings[key] = nullType
-			} else {
-				switch s := value.(type) {
-				case *sql.NullString:
-					if s.Valid {
-						dataStrings[key] = "'" + sanitize(s.String) + "'"
-					} else {
-						dataStrings[key] = nullType
-					}
-				case *sql.NullInt64:
-					if s.Valid {
-						dataStrings[key] = fmt.Sprintf("%d", s.Int64)
-					} else {
-						dataStrings[key] = nullType
-					}
-				case *sql.RawBytes:
-					if len(*s) == 0 {
-						dataStrings[key] = nullType
-					} else {
-						dataStrings[key] = "_binary '" + sanitize(string(*s)) + "'"
-					}
-				default:
-					dataStrings[key] = fmt.Sprint("'", value, "'")
+	for key, value := range table.values {
+		if value == nil {
+			dataStrings[key] = nullType
+		} else {
+			switch s := value.(type) {
+			case *sql.NullString:
+				if s.Valid {
+					dataStrings[key] = "'" + sanitize(s.String) + "'"
+				} else {
+					dataStrings[key] = nullType
 				}
+			case *sql.NullInt64:
+				if s.Valid {
+					dataStrings[key] = fmt.Sprintf("%d", s.Int64)
+				} else {
+					dataStrings[key] = nullType
+				}
+			case *sql.RawBytes:
+				if len(*s) == 0 {
+					dataStrings[key] = nullType
+				} else {
+					dataStrings[key] = "_binary '" + sanitize(string(*s)) + "'"
+				}
+			default:
+				dataStrings[key] = fmt.Sprint("'", value, "'")
 			}
 		}
-
-		dataText = append(dataText, "("+strings.Join(dataStrings, ",")+")")
 	}
 
-	return dataText, rows.Err()
+	return "(" + strings.Join(dataStrings, ",") + ")", table.rows.Err()
 }