go-hep.org/x/hep@v0.38.1/groot/rsql/rsqldrv/rsqldrv_example_test.go (about)

     1  // Copyright ©2019 The go-hep Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package rsqldrv_test
     6  
     7  import (
     8  	"database/sql"
     9  	"fmt"
    10  	"log"
    11  
    12  	"go-hep.org/x/hep/groot"
    13  	"go-hep.org/x/hep/groot/rsql/rsqldrv"
    14  	"go-hep.org/x/hep/groot/rtree"
    15  )
    16  
    17  func ExampleOpen() {
    18  	db, err := sql.Open("root", "../../testdata/simple.root")
    19  	if err != nil {
    20  		log.Fatal(err)
    21  	}
    22  	defer db.Close()
    23  
    24  	rows, err := db.Query("SELECT * FROM tree")
    25  	if err != nil {
    26  		log.Fatal(err)
    27  	}
    28  	defer rows.Close()
    29  
    30  	type data struct {
    31  		i32 int32
    32  		f32 float32
    33  		str string
    34  	}
    35  
    36  	n := 0
    37  	for rows.Next() {
    38  		var v data
    39  		err := rows.Scan(&v.i32, &v.f32, &v.str)
    40  		if err != nil {
    41  			log.Fatal(err)
    42  		}
    43  		fmt.Printf("row[%d]: (%v, %v, %q)\n", n, v.i32, v.f32, v.str)
    44  		n++
    45  	}
    46  
    47  	// Output:
    48  	// row[0]: (1, 1.1, "uno")
    49  	// row[1]: (2, 2.2, "dos")
    50  	// row[2]: (3, 3.3, "tres")
    51  	// row[3]: (4, 4.4, "quatro")
    52  }
    53  
    54  func ExampleOpen_tuple() {
    55  	db, err := sql.Open("root", "../../testdata/simple.root")
    56  	if err != nil {
    57  		log.Fatal(err)
    58  	}
    59  	defer db.Close()
    60  
    61  	rows, err := db.Query("SELECT (one, two, three) FROM tree")
    62  	if err != nil {
    63  		log.Fatal(err)
    64  	}
    65  	defer rows.Close()
    66  
    67  	type data struct {
    68  		i32 int32
    69  		f32 float32
    70  		str string
    71  	}
    72  
    73  	n := 0
    74  	for rows.Next() {
    75  		var v data
    76  		err := rows.Scan(&v.i32, &v.f32, &v.str)
    77  		if err != nil {
    78  			log.Fatal(err)
    79  		}
    80  		fmt.Printf("row[%d]: (%v, %v, %q)\n", n, v.i32, v.f32, v.str)
    81  		n++
    82  	}
    83  
    84  	// Output:
    85  	// row[0]: (1, 1.1, "uno")
    86  	// row[1]: (2, 2.2, "dos")
    87  	// row[2]: (3, 3.3, "tres")
    88  	// row[3]: (4, 4.4, "quatro")
    89  }
    90  
    91  func ExampleOpen_whereStmt() {
    92  	db, err := sql.Open("root", "../../testdata/simple.root")
    93  	if err != nil {
    94  		log.Fatal(err)
    95  	}
    96  	defer db.Close()
    97  
    98  	rows, err := db.Query("SELECT (one, two, three) FROM tree WHERE (one>2 && two < 5)")
    99  	if err != nil {
   100  		log.Fatal(err)
   101  	}
   102  	defer rows.Close()
   103  
   104  	type data struct {
   105  		i32 int32
   106  		f32 float32
   107  		str string
   108  	}
   109  
   110  	n := 0
   111  	for rows.Next() {
   112  		var v data
   113  		err := rows.Scan(&v.i32, &v.f32, &v.str)
   114  		if err != nil {
   115  			log.Fatal(err)
   116  		}
   117  		fmt.Printf("row[%d]: (%v, %v, %q)\n", n, v.i32, v.f32, v.str)
   118  		n++
   119  	}
   120  
   121  	// Output:
   122  	// row[0]: (3, 3.3, "tres")
   123  	// row[1]: (4, 4.4, "quatro")
   124  }
   125  
   126  func ExampleOpen_connector() {
   127  	f, err := groot.Open("../../testdata/simple.root")
   128  	if err != nil {
   129  		log.Fatal(err)
   130  	}
   131  	defer f.Close()
   132  
   133  	o, err := f.Get("tree")
   134  	if err != nil {
   135  		log.Fatal(err)
   136  	}
   137  
   138  	tree := o.(rtree.Tree)
   139  
   140  	db := sql.OpenDB(rsqldrv.Connector(rtree.FileOf(tree)))
   141  	defer db.Close()
   142  
   143  	rows, err := db.Query("SELECT * FROM tree")
   144  	if err != nil {
   145  		log.Fatal(err)
   146  	}
   147  	defer rows.Close()
   148  
   149  	type data struct {
   150  		i32 int32
   151  		f32 float32
   152  		str string
   153  	}
   154  
   155  	n := 0
   156  	for rows.Next() {
   157  		var v data
   158  		err = rows.Scan(&v.i32, &v.f32, &v.str)
   159  		if err != nil {
   160  			log.Fatal(err)
   161  		}
   162  		fmt.Printf("row[%d]: (%v, %v, %q)\n", n, v.i32, v.f32, v.str)
   163  		n++
   164  	}
   165  
   166  	// Output:
   167  	// row[0]: (1, 1.1, "uno")
   168  	// row[1]: (2, 2.2, "dos")
   169  	// row[2]: (3, 3.3, "tres")
   170  	// row[3]: (4, 4.4, "quatro")
   171  }