Esempio n. 1
0
func (t *table) fetchResult(itemT reflect.Type, rows *sql.Rows, columns []string) (item reflect.Value, err error) {
	expecting := len(columns)

	scanArgs := make([]interface{}, expecting)

	switch itemT.Kind() {
	case reflect.Struct:
		// Creating new value of the expected type.
		item = reflect.New(itemT)
		// Pairing each column with its index.
		for i, columnName := range columns {
			index := util.GetStructFieldIndex(itemT, columnName)
			if len(index) > 0 {
				destF := item.Elem().FieldByIndex(index)
				scanArgs[i] = destF.Addr().Interface()
			} else {
				var placeholder sql.RawBytes
				scanArgs[i] = &placeholder
			}
		}

		err = rows.Scan(scanArgs...)

		if err != nil {
			return item, err
		}
	case reflect.Map:
		values := make([]*sql.RawBytes, len(columns))
		for i := range columns {
			scanArgs[i] = &values[i]
		}
		err = rows.Scan(scanArgs...)

		if err == nil {
			item = reflect.MakeMap(itemT)
			for i, columnName := range columns {
				valS := string(*values[i])

				var vv reflect.Value

				if _, ok := t.columnTypes[columnName]; ok == true {
					v, _ := to.Convert(valS, t.columnTypes[columnName])
					vv = reflect.ValueOf(v)
				} else {
					v, _ := to.Convert(valS, reflect.String)
					vv = reflect.ValueOf(v)
				}

				vk := reflect.ValueOf(columnName)
				item.SetMapIndex(vk, vv)
			}
		}

		return item, err
	default:
		return item, db.ErrExpectingMapOrStruct
	}

	return item, nil
}
Esempio n. 2
0
File: util.go Progetto: vimdude/db
func (self *t) qlFetchResult(item_t reflect.Type, rows *sql.Rows, columns []string) (item reflect.Value, err error) {
	expecting := len(columns)

	scanArgs := make([]interface{}, expecting)

	switch item_t.Kind() {
	case reflect.Struct:
		// Creating new value of the expected type.
		item = reflect.New(item_t)
		// Pairing each column with its index.
		for i, columnName := range columns {
			index := util.GetStructFieldIndex(item_t, columnName)
			if index != nil {
				dest_f := item.Elem().FieldByIndex(index)
				scanArgs[i] = dest_f.Addr().Interface()
			}
		}

		err = rows.Scan(scanArgs...)

		if err != nil {
			return item, err
		}
	case reflect.Map:
		values := make([]*sql.RawBytes, len(columns))
		for i, _ := range columns {
			scanArgs[i] = &values[i]
		}
		err = rows.Scan(scanArgs...)

		if err == nil {
			item = reflect.MakeMap(item_t)
			for i, columnName := range columns {
				val_s := string(*values[i])

				var val_v reflect.Value

				if _, ok := self.ColumnTypes[columnName]; ok == true {
					v, _ := to.Convert(val_s, self.ColumnTypes[columnName])
					val_v = reflect.ValueOf(v)
				} else {
					v, _ := to.Convert(val_s, reflect.String)
					val_v = reflect.ValueOf(v)
				}

				key_v := reflect.ValueOf(columnName)
				item.SetMapIndex(key_v, val_v)
			}
		}

		return item, err
	default:
		return item, db.ErrExpectingMapOrStruct
	}

	return item, nil
}
Esempio n. 3
0
File: main.go Progetto: pzduniak/db
func (self *T) fetchResult(itemt reflect.Type, rows *sql.Rows, columns []string) (reflect.Value, error) {
	var err error

	var item reflect.Value

	expecting := len(columns)

	// Allocating results.
	values := make([]*sql.RawBytes, expecting)
	scanArgs := make([]interface{}, expecting)

	for i := range columns {
		scanArgs[i] = &values[i]
	}

	switch itemt.Kind() {
	case reflect.Map:
		item = reflect.MakeMap(itemt)
	case reflect.Struct:
		item = reflect.New(itemt)
	default:
		return item, db.ErrExpectingMapOrStruct
	}

	err = rows.Scan(scanArgs...)

	if err != nil {
		return item, err
	}

	// Range over row values.
	for i, value := range values {

		if value != nil {
			// Real column name
			column := columns[i]
			// Value as string.
			svalue := string(*value)

			var cv reflect.Value

			if _, ok := self.ColumnTypes[column]; ok == true {
				v, _ := to.Convert(svalue, self.ColumnTypes[column])
				cv = reflect.ValueOf(v)
			} else {
				v, _ := to.Convert(svalue, reflect.String)
				cv = reflect.ValueOf(v)
			}

			switch itemt.Kind() {
			// Destination is a map.
			case reflect.Map:
				if cv.Type() != itemt.Elem() {
					if itemt.Elem().Kind() == reflect.Interface {
						cv, _ = util.StringToType(svalue, cv.Type())
					} else {
						cv, _ = util.StringToType(svalue, itemt.Elem())
					}
				}
				if cv.IsValid() {
					item.SetMapIndex(reflect.ValueOf(column), cv)
				}
			// Destionation is a struct.
			case reflect.Struct:

				index := util.GetStructFieldIndex(itemt, column)

				if index == nil {
					continue
				} else {

					// Destination field.
					destf := item.Elem().FieldByIndex(index)

					if destf.IsValid() {
						if cv.Type() != destf.Type() {
							if destf.Type().Kind() != reflect.Interface {
								cv, _ = util.StringToType(svalue, destf.Type())
							}
						}
						// Copying value.
						if cv.IsValid() {
							destf.Set(cv)
						}
					}

				}
			}
		}
	}

	return item, nil
}
Esempio n. 4
0
func fetchResult(itemT reflect.Type, rows *sql.Rows, columns []string) (reflect.Value, error) {
	var item reflect.Value
	var err error

	switch itemT.Kind() {
	case reflect.Map:
		item = reflect.MakeMap(itemT)
	case reflect.Struct:
		item = reflect.New(itemT)
	default:
		return item, db.ErrExpectingMapOrStruct
	}

	expecting := len(columns)

	// Allocating results.
	values := make([]*sql.RawBytes, expecting)
	scanArgs := make([]interface{}, expecting)

	for i := range columns {
		scanArgs[i] = &values[i]
	}

	if err = rows.Scan(scanArgs...); err != nil {
		return item, err
	}

	// Range over row values.
	for i, value := range values {

		if value != nil {
			// Real column name
			column := columns[i]

			// Value as string.
			svalue := string(*value)

			var cv reflect.Value

			v, _ := to.Convert(svalue, reflect.String)
			cv = reflect.ValueOf(v)

			switch itemT.Kind() {
			// Destination is a map.
			case reflect.Map:
				if cv.Type() != itemT.Elem() {
					if itemT.Elem().Kind() == reflect.Interface {
						cv, _ = util.StringToType(svalue, cv.Type())
					} else {
						cv, _ = util.StringToType(svalue, itemT.Elem())
					}
				}
				if cv.IsValid() {
					item.SetMapIndex(reflect.ValueOf(column), cv)
				}
			// Destionation is a struct.
			case reflect.Struct:

				index := util.GetStructFieldIndex(itemT, column)

				if index == nil {
					continue
				} else {

					// Destination field.
					destf := item.Elem().FieldByIndex(index)

					if destf.IsValid() {

						if cv.Type() != destf.Type() {

							if destf.Type().Kind() != reflect.Interface {

								switch destf.Type() {
								case nullFloat64Type:
									nullFloat64 := sql.NullFloat64{}
									if svalue != `` {
										nullFloat64.Scan(svalue)
									}
									cv = reflect.ValueOf(nullFloat64)
								case nullInt64Type:
									nullInt64 := sql.NullInt64{}
									if svalue != `` {
										nullInt64.Scan(svalue)
									}
									cv = reflect.ValueOf(nullInt64)
								case nullBoolType:
									nullBool := sql.NullBool{}
									if svalue != `` {
										nullBool.Scan(svalue)
									}
									cv = reflect.ValueOf(nullBool)
								case nullStringType:
									nullString := sql.NullString{}
									nullString.Scan(svalue)
									cv = reflect.ValueOf(nullString)
								default:
									var decodingNull bool

									if svalue == "" {
										decodingNull = true
									}

									u, _ := indirect(destf, decodingNull)

									if u != nil {
										u.UnmarshalDB(svalue)

										if destf.Kind() == reflect.Interface || destf.Kind() == reflect.Ptr {
											cv = reflect.ValueOf(u)
										} else {
											cv = reflect.ValueOf(u).Elem()
										}

									} else {
										cv, _ = util.StringToType(svalue, destf.Type())
									}

								}
							}

						}

						// Copying value.
						if cv.IsValid() {
							destf.Set(cv)
						}

					}
				}

			}
		}
	}

	return item, nil
}