vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/select_json_object_test.go

   1 package oss
   2
   3 import (
   4         . "gopkg.in/check.v1"
   5         "os"
   6         "io/ioutil"
   7         "strings"
   8         "net/http"
   9 )
  10
  11 type OssSelectJsonSuite struct {
  12         client *Client
  13         bucket *Bucket
  14 }
  15
  16 var _ = Suite(&OssSelectJsonSuite{})
  17
  18 func (s *OssSelectJsonSuite) SetUpSuite(c *C) {
  19         client, err := New(endpoint, accessID, accessKey)
  20         c.Assert(err, IsNil)
  21         s.client = client
  22         s.client.Config.LogLevel = Error // Debug
  23         err = s.client.CreateBucket(bucketName)
  24         c.Assert(err, IsNil)
  25         bucket, err := s.client.Bucket(bucketName)
  26         c.Assert(err, IsNil)
  27         s.bucket = bucket
  28
  29         testLogger.Println("test select json started")
  30 }
  31
  32 func(s *OssSelectJsonSuite) TearDownSuite(c *C){
  33         // Delete objects
  34         marker := Marker("")
  35         for {
  36                 lor, err := s.bucket.ListObjects(marker)
  37                 c.Assert(err, IsNil)
  38                 for _, object := range lor.Objects {
  39                         err = s.bucket.DeleteObject(object.Key)
  40                         c.Assert(err, IsNil)
  41                 }
  42                 marker = Marker(lor.NextMarker)
  43                 if !lor.IsTruncated {
  44                         break
  45                 }
  46         }
  47
  48         err := s.client.DeleteBucket(bucketName)
  49         c.Assert(err, IsNil)
  50
  51         testLogger.Println("test select json completed")
  52 }
  53
  54 func (s *OssSelectJsonSuite) SetUpTest(c *C) {
  55         testLogger.Println("test func", c.TestName(), "start")
  56 }
  57
  58 func (s *OssSelectJsonSuite) TearDownTest(c *C) {
  59         testLogger.Println("test func", c.TestName(), "succeed")
  60 }
  61
  62 func (s *OssSelectJsonSuite) TestCreateSelectJsonObjectMeta(c *C){
  63         key := "sample_json_lines.json"
  64         err := s.bucket.PutObjectFromFile(key, "../sample/sample_json_lines.json")
  65         c.Assert(err, IsNil)
  66         jsonMeta := JsonMetaRequest{
  67                 InputSerialization: InputSerialization {
  68                         JSON: JSON {
  69                                 JSONType:"LINES",
  70                         },
  71                 },
  72         }
  73         res,err := s.bucket.CreateSelectJsonObjectMeta(key, jsonMeta)
  74         c.Assert(err, IsNil)
  75         c.Assert(res.RowsCount, Equals, int64(100))
  76
  77         err = s.bucket.DeleteObject(key)
  78         c.Assert(err, IsNil)
  79 }
  80
  81 func (s *OssSelectJsonSuite) TestSelectJsonDocument(c *C){
  82         key := "sample_json.json"
  83         err := s.bucket.PutObjectFromFile(key, "../sample/sample_json.json")
  84         c.Assert(err, IsNil)
  85         selReq := SelectRequest{}
  86         selReq.Expression = "select * from ossobject.objects[*] where party = 'Democrat'"
  87         selReq.InputSerializationSelect.JsonBodyInput.JSONType = "DOCUMENT"
  88         selReq.OutputSerializationSelect.JsonBodyOutput.RecordDelimiter = ","
  89
  90         var responseHeader http.Header
  91         body, err := s.bucket.SelectObject(key, selReq, GetResponseHeader(&responseHeader))
  92         c.Assert(err, IsNil)
  93         defer body.Close()
  94         requestId := GetRequestId(responseHeader)
  95         c.Assert(len(requestId) > 0, Equals, true)
  96
  97         p := make([]byte, 512)
  98         n, err := body.Read(p)
  99         c.Assert(err, IsNil)
 100         c.Assert(n, Equals, 512)
 101         p1 := make([]byte, 3)
 102         _, err = body.Read(p1)
 103         c.Assert(err, IsNil)
 104         rets, err := ioutil.ReadAll(body)
 105         c.Assert(err,IsNil)
 106         str,err := readJsonDocument("../sample/sample_json.json")
 107         c.Assert(err, IsNil)
 108         c.Assert(string(p) + string(p1) + string(rets), Equals, str)
 109
 110         err = s.bucket.DeleteObject(key)
 111         c.Assert(err, IsNil)
 112 }
 113
 114 func (s *OssSelectJsonSuite) TestSelectJsonLines(c *C) {
 115         key := "sample_json_lines.json"
 116         err := s.bucket.PutObjectFromFile(key, "../sample/sample_json_lines.json")
 117         c.Assert(err, IsNil)
 118         selReq := SelectRequest{}
 119         selReq.Expression = "select * from ossobject where party = 'Democrat'"
 120         selReq.OutputSerializationSelect.JsonBodyOutput.RecordDelimiter = ","
 121         selReq.InputSerializationSelect.JsonBodyInput.JSONType = "LINES"
 122
 123         var responseHeader http.Header
 124         body, err := s.bucket.SelectObject(key, selReq, GetResponseHeader(&responseHeader))
 125         c.Assert(err, IsNil)
 126         defer body.Close()
 127
 128         requestId := GetRequestId(responseHeader)
 129         c.Assert(len(requestId) > 0, Equals, true)
 130
 131         rets, err := ioutil.ReadAll(body)
 132         c.Assert(err,IsNil)
 133         str,err := readJsonDocument("../sample/sample_json.json")
 134         c.Assert(string(rets), Equals, str)
 135
 136         err = s.bucket.DeleteObject(key)
 137         c.Assert(err, IsNil)
 138 }
 139
 140 func (s *OssSelectJsonSuite) TestSelectJsonLinesIntoFile(c *C) {
 141         key := "sample_json_lines.json"
 142         err := s.bucket.PutObjectFromFile(key, "../sample/sample_json_lines.json")
 143         c.Assert(err, IsNil)
 144
 145         jsonMeta := JsonMetaRequest{
 146                 InputSerialization: InputSerialization {
 147                         JSON: JSON {
 148                                 JSONType:"LINES",
 149                         },
 150                 },
 151         }
 152         res,err := s.bucket.CreateSelectJsonObjectMeta(key, jsonMeta)
 153         c.Assert(err, IsNil)
 154         c.Assert(res.RowsCount, Equals, int64(100))
 155
 156         selReq := SelectRequest{}
 157         selReq.Expression = "select * from ossobject where party = 'Democrat'"
 158         selReq.OutputSerializationSelect.JsonBodyOutput.RecordDelimiter = ","
 159         selReq.InputSerializationSelect.JsonBodyInput.JSONType = "LINES"
 160
 161         var responseHeader http.Header
 162         outfile := "sample_json_out.json"
 163         err = s.bucket.SelectObjectIntoFile(key, outfile, selReq, GetResponseHeader(&responseHeader))
 164         c.Assert(err, IsNil)
 165         requestId := GetRequestId(responseHeader)
 166         c.Assert(len(requestId) > 0, Equals, true)
 167
 168         _, err = os.Stat(outfile)
 169         c.Assert(err,IsNil)
 170         err = os.Remove(outfile)
 171         c.Assert(err, IsNil)
 172
 173         err = s.bucket.DeleteObject(key)
 174         c.Assert(err, IsNil)
 175 }
 176
 177 func (s *OssSelectJsonSuite) TestSelectJsonDocumentIntoFile(c *C) {
 178         key := "sample_json_lines.json"
 179         err := s.bucket.PutObjectFromFile(key, "../sample/sample_json.json")
 180         c.Assert(err, IsNil)
 181
 182         selReq := SelectRequest{}
 183         selReq.Expression = "select * from ossobject.objects[*] where party = 'Democrat'"
 184         selReq.OutputSerializationSelect.JsonBodyOutput.RecordDelimiter = ","
 185         selReq.InputSerializationSelect.JsonBodyInput.JSONType = "DOCUMENT"
 186
 187         var responseHeader http.Header
 188         outfile := "sample_json_out.json"
 189         err = s.bucket.SelectObjectIntoFile(key, outfile, selReq, GetResponseHeader(&responseHeader))
 190         c.Assert(err, IsNil)
 191         requestId := GetRequestId(responseHeader)
 192         c.Assert(len(requestId) > 0, Equals, true)
 193
 194         _, err = os.Stat(outfile)
 195         c.Assert(err,IsNil)
 196         err = os.Remove(outfile)
 197         c.Assert(err, IsNil)
 198
 199         err = s.bucket.DeleteObject(key)
 200         c.Assert(err, IsNil)
 201 }
 202
 203 func (s *OssSelectJsonSuite) TestSelectJsonLinesLike(c *C) {
 204         key := "sample_json_lines.json"
 205         err := s.bucket.PutObjectFromFile(key, "../sample/sample_json_lines.json")
 206         c.Assert(err, IsNil)
 207         selReq := SelectRequest{}
 208         selReq.Expression = "select person.firstname, person.lastname from ossobject where person.birthday like '1959%'"
 209         selReq.OutputSerializationSelect.JsonBodyOutput.RecordDelimiter = ","
 210         selReq.InputSerializationSelect.JsonBodyInput.JSONType = "LINES"
 211
 212         jsonMeta := JsonMetaRequest{
 213                 InputSerialization: InputSerialization {
 214                         JSON: JSON {
 215                                 JSONType:"LINES",
 216                         },
 217                 },
 218         }
 219         res,err := s.bucket.CreateSelectJsonObjectMeta(key, jsonMeta)
 220         c.Assert(err, IsNil)
 221         c.Assert(res.RowsCount, Equals, int64(100))
 222
 223         var responseHeader http.Header
 224         body, err := s.bucket.SelectObject(key, selReq, GetResponseHeader(&responseHeader))
 225         c.Assert(err, IsNil)
 226         defer body.Close()
 227
 228         requestId := GetRequestId(responseHeader)
 229         c.Assert(len(requestId) > 0, Equals, true)
 230
 231         rets, err := ioutil.ReadAll(body)
 232         c.Assert(err,IsNil)
 233         str,err := readJsonLinesLike("../sample/sample_json.json")
 234         c.Assert(string(rets), Equals, str)
 235
 236         err = s.bucket.DeleteObject(key)
 237         c.Assert(err, IsNil)
 238 }
 239
 240 func (s *OssSelectJsonSuite) TestSelectJsonLinesRange(c *C) {
 241         key := "sample_json_lines.json"
 242         err := s.bucket.PutObjectFromFile(key, "../sample/sample_json_lines.json")
 243         c.Assert(err, IsNil)
 244         jsonMeta := JsonMetaRequest{
 245                 InputSerialization: InputSerialization {
 246                         JSON: JSON {
 247                                 JSONType:"LINES",
 248                         },
 249                 },
 250         }
 251         res,err := s.bucket.CreateSelectJsonObjectMeta(key, jsonMeta)
 252         c.Assert(err, IsNil)
 253         c.Assert(res.RowsCount, Equals, int64(100))
 254
 255         selReq := SelectRequest{}
 256         selReq.Expression = "select person.firstname as aaa as firstname, person.lastname, extra from ossobject'"
 257         selReq.OutputSerializationSelect.JsonBodyOutput.RecordDelimiter = ","
 258         selReq.InputSerializationSelect.JsonBodyInput.JSONType = "LINES"
 259         selReq.InputSerializationSelect.JsonBodyInput.Range = "0-1"
 260
 261         var responseHeader http.Header
 262         body, err := s.bucket.SelectObject(key, selReq, GetResponseHeader(&responseHeader))
 263         c.Assert(err, IsNil)
 264         defer body.Close()
 265
 266         requestId := GetRequestId(responseHeader)
 267         c.Assert(len(requestId) > 0, Equals, true)
 268
 269         rets, err := ioutil.ReadAll(body)
 270         c.Assert(err,IsNil)
 271         str,err := readJsonLinesRange("../sample/sample_json.json", 0, 2)
 272         c.Assert(string(rets), Equals, str)
 273
 274         err = s.bucket.DeleteObject(key)
 275         c.Assert(err, IsNil)
 276 }
 277
 278 func (s *OssSelectJsonSuite) TestSelectJsonDocumentIntAggregation(c *C) {
 279         key := "sample_json.json"
 280         err := s.bucket.PutObjectFromFile(key, "../sample/sample_json.json")
 281         c.Assert(err, IsNil)
 282
 283         selReq := SelectRequest{}
 284         selReq.Expression = `
 285         select
 286                 avg(cast(person.cspanid as int)), max(cast(person.cspanid as int)),
 287                 min(cast(person.cspanid as int))
 288         from
 289                 ossobject.objects[*]
 290         where
 291                 person.cspanid = 1011723
 292         `
 293         selReq.OutputSerializationSelect.JsonBodyOutput.RecordDelimiter = ","
 294         selReq.InputSerializationSelect.JsonBodyInput.JSONType = "Document"
 295
 296         body, err := s.bucket.SelectObject(key, selReq)
 297         c.Assert(err, IsNil)
 298         defer body.Close()
 299
 300         rets, err := ioutil.ReadAll(body)
 301         c.Assert(err,IsNil)
 302         c.Assert(string(rets), Equals, "{\"_1\":1011723,\"_2\":1011723,\"_3\":1011723},")
 303
 304         err = s.bucket.DeleteObject(key)
 305         c.Assert(err, IsNil)
 306 }
 307
 308 func (s *OssSelectJsonSuite) TestSelectJsonDocumentFloatAggregation(c *C) {
 309         key := "sample_json.json"
 310         err := s.bucket.PutObjectFromFile(key, "../sample/sample_json.json")
 311         c.Assert(err, IsNil)
 312
 313         selReq := SelectRequest{}
 314         selReq.Expression = `
 315         select
 316                 avg(cast(person.cspanid as double)), max(cast(person.cspanid as double)),
 317                 min(cast(person.cspanid as double))
 318         from
 319                 ossobject.objects[*]
 320         `
 321         selReq.OutputSerializationSelect.JsonBodyOutput.RecordDelimiter = ","
 322         selReq.InputSerializationSelect.JsonBodyInput.JSONType = "Document"
 323
 324         body, err := s.bucket.SelectObject(key, selReq)
 325         c.Assert(err, IsNil)
 326         defer body.Close()
 327
 328         rets, err := ioutil.ReadAll(body)
 329         c.Assert(err,IsNil)
 330         testLogger.Println(string(rets))
 331         // avg, max, min, err := readJsonFloatAggregation("../sample/sample_json.json")
 332         // fmt.Println(string(rets), "\n", avg, max, min)
 333         // retsArr := strings.Split(string(rets), ":")
 334         // s1 := strconv.FormatFloat(avg, 'f', 6, 64) + ","
 335         // s1 += strconv.FormatFloat(max, 'f', 6, 64) + ","
 336         // s1 += strconv.FormatFloat(min, 'f', 6, 64) + ","
 337         // retS := ""
 338         // l := len(retsArr[1])
 339         // vv, err := strconv.ParseFloat(retsArr[1][:l-35], 64)
 340         // c.Assert(err, IsNil)
 341         // retS += strconv.FormatFloat(vv, 'f', 6, 64) + ","
 342         // l = len(retsArr[2])
 343         // vv, err = strconv.ParseFloat(retsArr[2][:l-6], 64)
 344         // c.Assert(err, IsNil)
 345         // retS += strconv.FormatFloat(vv, 'f', 6, 64) + ","
 346         // l = len(retsArr[3])
 347         // vv, err = strconv.ParseFloat(retsArr[3][:l-2], 64)
 348         // c.Assert(err, IsNil)
 349         // retS += strconv.FormatFloat(vv, 'f', 6, 64) + ","
 350         // c.Assert(retS, Equals, s1)
 351
 352         err = s.bucket.DeleteObject(key)
 353         c.Assert(err, IsNil)
 354 }
 355
 356 func (s *OssSelectJsonSuite) TestSelectJsonDocumentConcat(c *C) {
 357         key := "sample_json.json"
 358         err := s.bucket.PutObjectFromFile(key, "../sample/sample_json.json")
 359         c.Assert(err, IsNil)
 360
 361         selReq := SelectRequest{}
 362         selReq.Expression = `
 363         select
 364                 person
 365         from
 366                 ossobject.objects[*]
 367         where
 368                 (person.firstname || person.lastname) = 'JohnKennedy'
 369         `
 370         selReq.OutputSerializationSelect.JsonBodyOutput.RecordDelimiter = ","
 371         selReq.InputSerializationSelect.JsonBodyInput.JSONType = "Document"
 372
 373         body, err := s.bucket.SelectObject(key, selReq)
 374         c.Assert(err, IsNil)
 375         defer body.Close()
 376
 377         rets, err := ioutil.ReadAll(body)
 378         c.Assert(err,IsNil)
 379         str, err := readJsonDocumentConcat("../sample/sample_json.json")
 380         c.Assert(err,IsNil)
 381         c.Assert(string(rets), Equals, str)
 382
 383         err = s.bucket.DeleteObject(key)
 384         c.Assert(err, IsNil)
 385 }
 386
 387 func (s *OssSelectJsonSuite) TestSelectJsonComplicateConcat(c *C) {
 388         key := "sample_json.json"
 389         err := s.bucket.PutObjectFromFile(key, "../sample/sample_json_lines.json")
 390         c.Assert(err, IsNil)
 391
 392         selReq := SelectRequest{}
 393         selReq.Expression = `
 394         select
 395                 person.firstname, person.lastname, congress_numbers
 396         from
 397                 ossobject
 398         where
 399                 startdate > '2017-01-01' and
 400                 senator_rank = 'junior' or
 401                 state = 'CA' and
 402                 party = 'Republican'
 403         `
 404         selReq.OutputSerializationSelect.JsonBodyOutput.RecordDelimiter = ","
 405         selReq.InputSerializationSelect.JsonBodyInput.JSONType = "LINES"
 406
 407         body, err := s.bucket.SelectObject(key, selReq)
 408         c.Assert(err, IsNil)
 409         defer body.Close()
 410
 411         rets, err := ioutil.ReadAll(body)
 412         c.Assert(err,IsNil)
 413         str, err := readJsonComplicateConcat("../sample/sample_json.json")
 414         c.Assert(err,IsNil)
 415         c.Assert(string(rets), Equals, str)
 416
 417         err = s.bucket.DeleteObject(key)
 418         c.Assert(err, IsNil)
 419 }
 420
 421 func (s *OssSelectJsonSuite) TestSelectJsonLineInvalidSql(c *C) {
 422         key := "sample_json.json"
 423         err := s.bucket.PutObjectFromFile(key, "../sample/sample_json_lines.json")
 424         c.Assert(err, IsNil)
 425
 426         selReq := SelectRequest{}
 427         selReq.OutputSerializationSelect.JsonBodyOutput.RecordDelimiter = ","
 428         selReq.InputSerializationSelect.JsonBodyInput.JSONType = "LINES"
 429
 430         selReq.Expression = `select * from ossobject where avg(cast(person.birthday as int)) > 2016`
 431         _, err = s.bucket.SelectObject(key, selReq)
 432         c.Assert(err, NotNil)
 433
 434         selReq.Expression = ``
 435         _, err = s.bucket.SelectObject(key, selReq)
 436         c.Assert(err, NotNil)
 437
 438         selReq.Expression = `select person.lastname || person.firstname from ossobject`
 439         _, err = s.bucket.SelectObject(key, selReq)
 440         c.Assert(err, NotNil)
 441
 442         selReq.Expression = `select * from ossobject group by person.firstname`
 443         _, err = s.bucket.SelectObject(key, selReq)
 444         c.Assert(err, NotNil)
 445
 446         selReq.Expression = `select * from ossobject order by _1`
 447         _, err = s.bucket.SelectObject(key, selReq)
 448         c.Assert(err, NotNil)
 449
 450         selReq.Expression = `select * from ossobject oss join s3object s3 on oss.CityName = s3.CityName`
 451         _, err = s.bucket.SelectObject(key, selReq)
 452         c.Assert(err, NotNil)
 453
 454         err = s.bucket.PutObjectFromFile(key, "../sample/sample_json.json")
 455         c.Assert(err, IsNil)
 456         selReq.InputSerializationSelect.JsonBodyInput.JSONType = "DOCUMENT"
 457         selReq.Expression = `select _1 from ossobject.objects[*]`
 458         body, err := s.bucket.SelectObject(key, selReq)
 459         c.Assert(err, IsNil)
 460         defer body.Close()
 461
 462         err = s.bucket.DeleteObject(key)
 463         c.Assert(err, IsNil)
 464 }
 465
 466 func (s *OssSelectJsonSuite) TestSelectJsonParseNumAsString(c *C) {
 467         key := "sample_json.json"
 468         content := "{\"a\":123456789.123456789}"
 469         err := s.bucket.PutObject(key, strings.NewReader(content))
 470         c.Assert(err, IsNil)
 471
 472         selReq := SelectRequest{}
 473         selReq.Expression = `select a from ossobject where cast(a as decimal) = 123456789.1234567890`
 474         bo := true
 475         selReq.InputSerializationSelect.JsonBodyInput.ParseJSONNumberAsString = &bo
 476         selReq.InputSerializationSelect.JsonBodyInput.JSONType = "DOCUMENT"
 477
 478         body, err := s.bucket.SelectObject(key, selReq)
 479         c.Assert(err, IsNil)
 480         defer body.Close()
 481
 482         rets, err := ioutil.ReadAll(body)
 483         c.Assert(err,IsNil)
 484         c.Assert(string(rets), Equals, "{\"a\":123456789.123456789}\n")
 485
 486         err = s.bucket.DeleteObject(key)
 487         c.Assert(err, IsNil)
 488 }