1 package catalog
2
3
4
5
6
7
8
9 import (
10 "context"
11 "encoding/json"
12 "github.com/Azure/go-autorest/autorest"
13 "github.com/Azure/go-autorest/autorest/date"
14 "github.com/Azure/go-autorest/autorest/to"
15 "github.com/Azure/go-autorest/tracing"
16 "github.com/gofrs/uuid"
17 "net/http"
18 )
19
20
21 const fqdn = "github.com/Azure/azure-sdk-for-go/services/datalake/analytics/2016-11-01-preview/catalog"
22
23
24 type ACL struct {
25
26 AceType ACLType `json:"aceType,omitempty"`
27
28 PrincipalID *uuid.UUID `json:"principalId,omitempty"`
29
30 Permission PermissionType `json:"permission,omitempty"`
31 }
32
33
34 func (a ACL) MarshalJSON() ([]byte, error) {
35 objectMap := make(map[string]interface{})
36 return json.Marshal(objectMap)
37 }
38
39
40 type ACLCreateOrUpdateParameters struct {
41
42 AceType ACLType `json:"aceType,omitempty"`
43
44 PrincipalID *uuid.UUID `json:"principalId,omitempty"`
45
46 Permission PermissionType `json:"permission,omitempty"`
47 }
48
49
50 type ACLDeleteParameters struct {
51
52 AceType ACLType `json:"aceType,omitempty"`
53
54 PrincipalID *uuid.UUID `json:"principalId,omitempty"`
55 }
56
57
58 type ACLList struct {
59 autorest.Response `json:"-"`
60
61 Value *[]ACL `json:"value,omitempty"`
62
63 NextLink *string `json:"nextLink,omitempty"`
64 }
65
66
67 func (al ACLList) MarshalJSON() ([]byte, error) {
68 objectMap := make(map[string]interface{})
69 if al.NextLink != nil {
70 objectMap["nextLink"] = al.NextLink
71 }
72 return json.Marshal(objectMap)
73 }
74
75
76 type ACLListIterator struct {
77 i int
78 page ACLListPage
79 }
80
81
82
83 func (iter *ACLListIterator) NextWithContext(ctx context.Context) (err error) {
84 if tracing.IsEnabled() {
85 ctx = tracing.StartSpan(ctx, fqdn+"/ACLListIterator.NextWithContext")
86 defer func() {
87 sc := -1
88 if iter.Response().Response.Response != nil {
89 sc = iter.Response().Response.Response.StatusCode
90 }
91 tracing.EndSpan(ctx, sc, err)
92 }()
93 }
94 iter.i++
95 if iter.i < len(iter.page.Values()) {
96 return nil
97 }
98 err = iter.page.NextWithContext(ctx)
99 if err != nil {
100 iter.i--
101 return err
102 }
103 iter.i = 0
104 return nil
105 }
106
107
108
109
110 func (iter *ACLListIterator) Next() error {
111 return iter.NextWithContext(context.Background())
112 }
113
114
115 func (iter ACLListIterator) NotDone() bool {
116 return iter.page.NotDone() && iter.i < len(iter.page.Values())
117 }
118
119
120 func (iter ACLListIterator) Response() ACLList {
121 return iter.page.Response()
122 }
123
124
125
126 func (iter ACLListIterator) Value() ACL {
127 if !iter.page.NotDone() {
128 return ACL{}
129 }
130 return iter.page.Values()[iter.i]
131 }
132
133
134 func NewACLListIterator(page ACLListPage) ACLListIterator {
135 return ACLListIterator{page: page}
136 }
137
138
139 func (al ACLList) IsEmpty() bool {
140 return al.Value == nil || len(*al.Value) == 0
141 }
142
143
144 func (al ACLList) hasNextLink() bool {
145 return al.NextLink != nil && len(*al.NextLink) != 0
146 }
147
148
149
150 func (al ACLList) aCLListPreparer(ctx context.Context) (*http.Request, error) {
151 if !al.hasNextLink() {
152 return nil, nil
153 }
154 return autorest.Prepare((&http.Request{}).WithContext(ctx),
155 autorest.AsJSON(),
156 autorest.AsGet(),
157 autorest.WithBaseURL(to.String(al.NextLink)))
158 }
159
160
161 type ACLListPage struct {
162 fn func(context.Context, ACLList) (ACLList, error)
163 al ACLList
164 }
165
166
167
168 func (page *ACLListPage) NextWithContext(ctx context.Context) (err error) {
169 if tracing.IsEnabled() {
170 ctx = tracing.StartSpan(ctx, fqdn+"/ACLListPage.NextWithContext")
171 defer func() {
172 sc := -1
173 if page.Response().Response.Response != nil {
174 sc = page.Response().Response.Response.StatusCode
175 }
176 tracing.EndSpan(ctx, sc, err)
177 }()
178 }
179 for {
180 next, err := page.fn(ctx, page.al)
181 if err != nil {
182 return err
183 }
184 page.al = next
185 if !next.hasNextLink() || !next.IsEmpty() {
186 break
187 }
188 }
189 return nil
190 }
191
192
193
194
195 func (page *ACLListPage) Next() error {
196 return page.NextWithContext(context.Background())
197 }
198
199
200 func (page ACLListPage) NotDone() bool {
201 return !page.al.IsEmpty()
202 }
203
204
205 func (page ACLListPage) Response() ACLList {
206 return page.al
207 }
208
209
210 func (page ACLListPage) Values() []ACL {
211 if page.al.IsEmpty() {
212 return nil
213 }
214 return *page.al.Value
215 }
216
217
218 func NewACLListPage(cur ACLList, getNextPage func(context.Context, ACLList) (ACLList, error)) ACLListPage {
219 return ACLListPage{
220 fn: getNextPage,
221 al: cur,
222 }
223 }
224
225
226
227 type DataLakeAnalyticsCatalogCredentialCreateParameters struct {
228
229 Password *string `json:"password,omitempty"`
230
231 URI *string `json:"uri,omitempty"`
232
233 UserID *string `json:"userId,omitempty"`
234 }
235
236
237
238 type DataLakeAnalyticsCatalogCredentialDeleteParameters struct {
239
240 Password *string `json:"password,omitempty"`
241 }
242
243
244
245 type DataLakeAnalyticsCatalogCredentialUpdateParameters struct {
246
247 Password *string `json:"password,omitempty"`
248
249 NewPassword *string `json:"newPassword,omitempty"`
250
251 URI *string `json:"uri,omitempty"`
252
253 UserID *string `json:"userId,omitempty"`
254 }
255
256
257
258
259 type DataLakeAnalyticsCatalogSecretCreateOrUpdateParameters struct {
260
261 Password *string `json:"password,omitempty"`
262
263 URI *string `json:"uri,omitempty"`
264 }
265
266
267 type DdlName struct {
268
269 FirstPart *string `json:"firstPart,omitempty"`
270
271 SecondPart *string `json:"secondPart,omitempty"`
272
273 ThirdPart *string `json:"thirdPart,omitempty"`
274
275 Server *string `json:"server,omitempty"`
276 }
277
278
279 type EntityID struct {
280
281 Name *DdlName `json:"name,omitempty"`
282
283 Version *uuid.UUID `json:"version,omitempty"`
284 }
285
286
287 type ExternalTable struct {
288
289 TableName *string `json:"tableName,omitempty"`
290
291 DataSource *EntityID `json:"dataSource,omitempty"`
292 }
293
294
295 type Item struct {
296
297 ComputeAccountName *string `json:"computeAccountName,omitempty"`
298
299 Version *uuid.UUID `json:"version,omitempty"`
300 }
301
302
303 type ItemList struct {
304
305 NextLink *string `json:"nextLink,omitempty"`
306 }
307
308
309 type TypeFieldInfo struct {
310
311 Name *string `json:"name,omitempty"`
312
313 Type *string `json:"type,omitempty"`
314 }
315
316
317 type USQLAssembly struct {
318 autorest.Response `json:"-"`
319
320 DatabaseName *string `json:"databaseName,omitempty"`
321
322 Name *string `json:"assemblyName,omitempty"`
323
324 ClrName *string `json:"clrName,omitempty"`
325
326 IsVisible *bool `json:"isVisible,omitempty"`
327
328 IsUserDefined *bool `json:"isUserDefined,omitempty"`
329
330 Files *[]USQLAssemblyFileInfo `json:"files,omitempty"`
331
332 Dependencies *[]USQLAssemblyDependencyInfo `json:"dependencies,omitempty"`
333
334 ComputeAccountName *string `json:"computeAccountName,omitempty"`
335
336 Version *uuid.UUID `json:"version,omitempty"`
337 }
338
339
340 type USQLAssemblyClr struct {
341
342 DatabaseName *string `json:"databaseName,omitempty"`
343
344 Name *string `json:"assemblyClrName,omitempty"`
345
346 ClrName *string `json:"clrName,omitempty"`
347
348 ComputeAccountName *string `json:"computeAccountName,omitempty"`
349
350 Version *uuid.UUID `json:"version,omitempty"`
351 }
352
353
354 type USQLAssemblyDependencyInfo struct {
355
356 EntityID *EntityID `json:"entityId,omitempty"`
357 }
358
359
360 type USQLAssemblyFileInfo struct {
361
362 Type FileType `json:"type,omitempty"`
363
364 OriginalPath *string `json:"originalPath,omitempty"`
365
366 ContentPath *string `json:"contentPath,omitempty"`
367 }
368
369
370 type USQLAssemblyList struct {
371 autorest.Response `json:"-"`
372
373 Value *[]USQLAssemblyClr `json:"value,omitempty"`
374
375 NextLink *string `json:"nextLink,omitempty"`
376 }
377
378
379 func (usal USQLAssemblyList) MarshalJSON() ([]byte, error) {
380 objectMap := make(map[string]interface{})
381 if usal.NextLink != nil {
382 objectMap["nextLink"] = usal.NextLink
383 }
384 return json.Marshal(objectMap)
385 }
386
387
388 type USQLAssemblyListIterator struct {
389 i int
390 page USQLAssemblyListPage
391 }
392
393
394
395 func (iter *USQLAssemblyListIterator) NextWithContext(ctx context.Context) (err error) {
396 if tracing.IsEnabled() {
397 ctx = tracing.StartSpan(ctx, fqdn+"/USQLAssemblyListIterator.NextWithContext")
398 defer func() {
399 sc := -1
400 if iter.Response().Response.Response != nil {
401 sc = iter.Response().Response.Response.StatusCode
402 }
403 tracing.EndSpan(ctx, sc, err)
404 }()
405 }
406 iter.i++
407 if iter.i < len(iter.page.Values()) {
408 return nil
409 }
410 err = iter.page.NextWithContext(ctx)
411 if err != nil {
412 iter.i--
413 return err
414 }
415 iter.i = 0
416 return nil
417 }
418
419
420
421
422 func (iter *USQLAssemblyListIterator) Next() error {
423 return iter.NextWithContext(context.Background())
424 }
425
426
427 func (iter USQLAssemblyListIterator) NotDone() bool {
428 return iter.page.NotDone() && iter.i < len(iter.page.Values())
429 }
430
431
432 func (iter USQLAssemblyListIterator) Response() USQLAssemblyList {
433 return iter.page.Response()
434 }
435
436
437
438 func (iter USQLAssemblyListIterator) Value() USQLAssemblyClr {
439 if !iter.page.NotDone() {
440 return USQLAssemblyClr{}
441 }
442 return iter.page.Values()[iter.i]
443 }
444
445
446 func NewUSQLAssemblyListIterator(page USQLAssemblyListPage) USQLAssemblyListIterator {
447 return USQLAssemblyListIterator{page: page}
448 }
449
450
451 func (usal USQLAssemblyList) IsEmpty() bool {
452 return usal.Value == nil || len(*usal.Value) == 0
453 }
454
455
456 func (usal USQLAssemblyList) hasNextLink() bool {
457 return usal.NextLink != nil && len(*usal.NextLink) != 0
458 }
459
460
461
462 func (usal USQLAssemblyList) uSQLAssemblyListPreparer(ctx context.Context) (*http.Request, error) {
463 if !usal.hasNextLink() {
464 return nil, nil
465 }
466 return autorest.Prepare((&http.Request{}).WithContext(ctx),
467 autorest.AsJSON(),
468 autorest.AsGet(),
469 autorest.WithBaseURL(to.String(usal.NextLink)))
470 }
471
472
473 type USQLAssemblyListPage struct {
474 fn func(context.Context, USQLAssemblyList) (USQLAssemblyList, error)
475 ual USQLAssemblyList
476 }
477
478
479
480 func (page *USQLAssemblyListPage) NextWithContext(ctx context.Context) (err error) {
481 if tracing.IsEnabled() {
482 ctx = tracing.StartSpan(ctx, fqdn+"/USQLAssemblyListPage.NextWithContext")
483 defer func() {
484 sc := -1
485 if page.Response().Response.Response != nil {
486 sc = page.Response().Response.Response.StatusCode
487 }
488 tracing.EndSpan(ctx, sc, err)
489 }()
490 }
491 for {
492 next, err := page.fn(ctx, page.ual)
493 if err != nil {
494 return err
495 }
496 page.ual = next
497 if !next.hasNextLink() || !next.IsEmpty() {
498 break
499 }
500 }
501 return nil
502 }
503
504
505
506
507 func (page *USQLAssemblyListPage) Next() error {
508 return page.NextWithContext(context.Background())
509 }
510
511
512 func (page USQLAssemblyListPage) NotDone() bool {
513 return !page.ual.IsEmpty()
514 }
515
516
517 func (page USQLAssemblyListPage) Response() USQLAssemblyList {
518 return page.ual
519 }
520
521
522 func (page USQLAssemblyListPage) Values() []USQLAssemblyClr {
523 if page.ual.IsEmpty() {
524 return nil
525 }
526 return *page.ual.Value
527 }
528
529
530 func NewUSQLAssemblyListPage(cur USQLAssemblyList, getNextPage func(context.Context, USQLAssemblyList) (USQLAssemblyList, error)) USQLAssemblyListPage {
531 return USQLAssemblyListPage{
532 fn: getNextPage,
533 ual: cur,
534 }
535 }
536
537
538 type USQLCredential struct {
539 autorest.Response `json:"-"`
540
541 Name *string `json:"credentialName,omitempty"`
542
543 ComputeAccountName *string `json:"computeAccountName,omitempty"`
544
545 Version *uuid.UUID `json:"version,omitempty"`
546 }
547
548
549 type USQLCredentialList struct {
550 autorest.Response `json:"-"`
551
552 Value *[]USQLCredential `json:"value,omitempty"`
553
554 NextLink *string `json:"nextLink,omitempty"`
555 }
556
557
558 func (uscl USQLCredentialList) MarshalJSON() ([]byte, error) {
559 objectMap := make(map[string]interface{})
560 if uscl.NextLink != nil {
561 objectMap["nextLink"] = uscl.NextLink
562 }
563 return json.Marshal(objectMap)
564 }
565
566
567 type USQLCredentialListIterator struct {
568 i int
569 page USQLCredentialListPage
570 }
571
572
573
574 func (iter *USQLCredentialListIterator) NextWithContext(ctx context.Context) (err error) {
575 if tracing.IsEnabled() {
576 ctx = tracing.StartSpan(ctx, fqdn+"/USQLCredentialListIterator.NextWithContext")
577 defer func() {
578 sc := -1
579 if iter.Response().Response.Response != nil {
580 sc = iter.Response().Response.Response.StatusCode
581 }
582 tracing.EndSpan(ctx, sc, err)
583 }()
584 }
585 iter.i++
586 if iter.i < len(iter.page.Values()) {
587 return nil
588 }
589 err = iter.page.NextWithContext(ctx)
590 if err != nil {
591 iter.i--
592 return err
593 }
594 iter.i = 0
595 return nil
596 }
597
598
599
600
601 func (iter *USQLCredentialListIterator) Next() error {
602 return iter.NextWithContext(context.Background())
603 }
604
605
606 func (iter USQLCredentialListIterator) NotDone() bool {
607 return iter.page.NotDone() && iter.i < len(iter.page.Values())
608 }
609
610
611 func (iter USQLCredentialListIterator) Response() USQLCredentialList {
612 return iter.page.Response()
613 }
614
615
616
617 func (iter USQLCredentialListIterator) Value() USQLCredential {
618 if !iter.page.NotDone() {
619 return USQLCredential{}
620 }
621 return iter.page.Values()[iter.i]
622 }
623
624
625 func NewUSQLCredentialListIterator(page USQLCredentialListPage) USQLCredentialListIterator {
626 return USQLCredentialListIterator{page: page}
627 }
628
629
630 func (uscl USQLCredentialList) IsEmpty() bool {
631 return uscl.Value == nil || len(*uscl.Value) == 0
632 }
633
634
635 func (uscl USQLCredentialList) hasNextLink() bool {
636 return uscl.NextLink != nil && len(*uscl.NextLink) != 0
637 }
638
639
640
641 func (uscl USQLCredentialList) uSQLCredentialListPreparer(ctx context.Context) (*http.Request, error) {
642 if !uscl.hasNextLink() {
643 return nil, nil
644 }
645 return autorest.Prepare((&http.Request{}).WithContext(ctx),
646 autorest.AsJSON(),
647 autorest.AsGet(),
648 autorest.WithBaseURL(to.String(uscl.NextLink)))
649 }
650
651
652 type USQLCredentialListPage struct {
653 fn func(context.Context, USQLCredentialList) (USQLCredentialList, error)
654 ucl USQLCredentialList
655 }
656
657
658
659 func (page *USQLCredentialListPage) NextWithContext(ctx context.Context) (err error) {
660 if tracing.IsEnabled() {
661 ctx = tracing.StartSpan(ctx, fqdn+"/USQLCredentialListPage.NextWithContext")
662 defer func() {
663 sc := -1
664 if page.Response().Response.Response != nil {
665 sc = page.Response().Response.Response.StatusCode
666 }
667 tracing.EndSpan(ctx, sc, err)
668 }()
669 }
670 for {
671 next, err := page.fn(ctx, page.ucl)
672 if err != nil {
673 return err
674 }
675 page.ucl = next
676 if !next.hasNextLink() || !next.IsEmpty() {
677 break
678 }
679 }
680 return nil
681 }
682
683
684
685
686 func (page *USQLCredentialListPage) Next() error {
687 return page.NextWithContext(context.Background())
688 }
689
690
691 func (page USQLCredentialListPage) NotDone() bool {
692 return !page.ucl.IsEmpty()
693 }
694
695
696 func (page USQLCredentialListPage) Response() USQLCredentialList {
697 return page.ucl
698 }
699
700
701 func (page USQLCredentialListPage) Values() []USQLCredential {
702 if page.ucl.IsEmpty() {
703 return nil
704 }
705 return *page.ucl.Value
706 }
707
708
709 func NewUSQLCredentialListPage(cur USQLCredentialList, getNextPage func(context.Context, USQLCredentialList) (USQLCredentialList, error)) USQLCredentialListPage {
710 return USQLCredentialListPage{
711 fn: getNextPage,
712 ucl: cur,
713 }
714 }
715
716
717 type USQLDatabase struct {
718 autorest.Response `json:"-"`
719
720 Name *string `json:"databaseName,omitempty"`
721
722 ComputeAccountName *string `json:"computeAccountName,omitempty"`
723
724 Version *uuid.UUID `json:"version,omitempty"`
725 }
726
727
728 type USQLDatabaseList struct {
729 autorest.Response `json:"-"`
730
731 Value *[]USQLDatabase `json:"value,omitempty"`
732
733 NextLink *string `json:"nextLink,omitempty"`
734 }
735
736
737 func (usdl USQLDatabaseList) MarshalJSON() ([]byte, error) {
738 objectMap := make(map[string]interface{})
739 if usdl.NextLink != nil {
740 objectMap["nextLink"] = usdl.NextLink
741 }
742 return json.Marshal(objectMap)
743 }
744
745
746 type USQLDatabaseListIterator struct {
747 i int
748 page USQLDatabaseListPage
749 }
750
751
752
753 func (iter *USQLDatabaseListIterator) NextWithContext(ctx context.Context) (err error) {
754 if tracing.IsEnabled() {
755 ctx = tracing.StartSpan(ctx, fqdn+"/USQLDatabaseListIterator.NextWithContext")
756 defer func() {
757 sc := -1
758 if iter.Response().Response.Response != nil {
759 sc = iter.Response().Response.Response.StatusCode
760 }
761 tracing.EndSpan(ctx, sc, err)
762 }()
763 }
764 iter.i++
765 if iter.i < len(iter.page.Values()) {
766 return nil
767 }
768 err = iter.page.NextWithContext(ctx)
769 if err != nil {
770 iter.i--
771 return err
772 }
773 iter.i = 0
774 return nil
775 }
776
777
778
779
780 func (iter *USQLDatabaseListIterator) Next() error {
781 return iter.NextWithContext(context.Background())
782 }
783
784
785 func (iter USQLDatabaseListIterator) NotDone() bool {
786 return iter.page.NotDone() && iter.i < len(iter.page.Values())
787 }
788
789
790 func (iter USQLDatabaseListIterator) Response() USQLDatabaseList {
791 return iter.page.Response()
792 }
793
794
795
796 func (iter USQLDatabaseListIterator) Value() USQLDatabase {
797 if !iter.page.NotDone() {
798 return USQLDatabase{}
799 }
800 return iter.page.Values()[iter.i]
801 }
802
803
804 func NewUSQLDatabaseListIterator(page USQLDatabaseListPage) USQLDatabaseListIterator {
805 return USQLDatabaseListIterator{page: page}
806 }
807
808
809 func (usdl USQLDatabaseList) IsEmpty() bool {
810 return usdl.Value == nil || len(*usdl.Value) == 0
811 }
812
813
814 func (usdl USQLDatabaseList) hasNextLink() bool {
815 return usdl.NextLink != nil && len(*usdl.NextLink) != 0
816 }
817
818
819
820 func (usdl USQLDatabaseList) uSQLDatabaseListPreparer(ctx context.Context) (*http.Request, error) {
821 if !usdl.hasNextLink() {
822 return nil, nil
823 }
824 return autorest.Prepare((&http.Request{}).WithContext(ctx),
825 autorest.AsJSON(),
826 autorest.AsGet(),
827 autorest.WithBaseURL(to.String(usdl.NextLink)))
828 }
829
830
831 type USQLDatabaseListPage struct {
832 fn func(context.Context, USQLDatabaseList) (USQLDatabaseList, error)
833 udl USQLDatabaseList
834 }
835
836
837
838 func (page *USQLDatabaseListPage) NextWithContext(ctx context.Context) (err error) {
839 if tracing.IsEnabled() {
840 ctx = tracing.StartSpan(ctx, fqdn+"/USQLDatabaseListPage.NextWithContext")
841 defer func() {
842 sc := -1
843 if page.Response().Response.Response != nil {
844 sc = page.Response().Response.Response.StatusCode
845 }
846 tracing.EndSpan(ctx, sc, err)
847 }()
848 }
849 for {
850 next, err := page.fn(ctx, page.udl)
851 if err != nil {
852 return err
853 }
854 page.udl = next
855 if !next.hasNextLink() || !next.IsEmpty() {
856 break
857 }
858 }
859 return nil
860 }
861
862
863
864
865 func (page *USQLDatabaseListPage) Next() error {
866 return page.NextWithContext(context.Background())
867 }
868
869
870 func (page USQLDatabaseListPage) NotDone() bool {
871 return !page.udl.IsEmpty()
872 }
873
874
875 func (page USQLDatabaseListPage) Response() USQLDatabaseList {
876 return page.udl
877 }
878
879
880 func (page USQLDatabaseListPage) Values() []USQLDatabase {
881 if page.udl.IsEmpty() {
882 return nil
883 }
884 return *page.udl.Value
885 }
886
887
888 func NewUSQLDatabaseListPage(cur USQLDatabaseList, getNextPage func(context.Context, USQLDatabaseList) (USQLDatabaseList, error)) USQLDatabaseListPage {
889 return USQLDatabaseListPage{
890 fn: getNextPage,
891 udl: cur,
892 }
893 }
894
895
896 type USQLDirectedColumn struct {
897
898 Name *string `json:"name,omitempty"`
899
900 Descending *bool `json:"descending,omitempty"`
901 }
902
903
904 type USQLDistributionInfo struct {
905
906 Type *int32 `json:"type,omitempty"`
907
908 Keys *[]USQLDirectedColumn `json:"keys,omitempty"`
909
910 Count *int32 `json:"count,omitempty"`
911
912 DynamicCount *int32 `json:"dynamicCount,omitempty"`
913 }
914
915
916 type USQLExternalDataSource struct {
917 autorest.Response `json:"-"`
918
919 DatabaseName *string `json:"databaseName,omitempty"`
920
921 Name *string `json:"externalDataSourceName,omitempty"`
922
923 Provider *string `json:"provider,omitempty"`
924
925 ProviderString *string `json:"providerString,omitempty"`
926
927 PushdownTypes *[]string `json:"pushdownTypes,omitempty"`
928
929 ComputeAccountName *string `json:"computeAccountName,omitempty"`
930
931 Version *uuid.UUID `json:"version,omitempty"`
932 }
933
934
935 type USQLExternalDataSourceList struct {
936 autorest.Response `json:"-"`
937
938 Value *[]USQLExternalDataSource `json:"value,omitempty"`
939
940 NextLink *string `json:"nextLink,omitempty"`
941 }
942
943
944 func (usedsl USQLExternalDataSourceList) MarshalJSON() ([]byte, error) {
945 objectMap := make(map[string]interface{})
946 if usedsl.NextLink != nil {
947 objectMap["nextLink"] = usedsl.NextLink
948 }
949 return json.Marshal(objectMap)
950 }
951
952
953
954 type USQLExternalDataSourceListIterator struct {
955 i int
956 page USQLExternalDataSourceListPage
957 }
958
959
960
961 func (iter *USQLExternalDataSourceListIterator) NextWithContext(ctx context.Context) (err error) {
962 if tracing.IsEnabled() {
963 ctx = tracing.StartSpan(ctx, fqdn+"/USQLExternalDataSourceListIterator.NextWithContext")
964 defer func() {
965 sc := -1
966 if iter.Response().Response.Response != nil {
967 sc = iter.Response().Response.Response.StatusCode
968 }
969 tracing.EndSpan(ctx, sc, err)
970 }()
971 }
972 iter.i++
973 if iter.i < len(iter.page.Values()) {
974 return nil
975 }
976 err = iter.page.NextWithContext(ctx)
977 if err != nil {
978 iter.i--
979 return err
980 }
981 iter.i = 0
982 return nil
983 }
984
985
986
987
988 func (iter *USQLExternalDataSourceListIterator) Next() error {
989 return iter.NextWithContext(context.Background())
990 }
991
992
993 func (iter USQLExternalDataSourceListIterator) NotDone() bool {
994 return iter.page.NotDone() && iter.i < len(iter.page.Values())
995 }
996
997
998 func (iter USQLExternalDataSourceListIterator) Response() USQLExternalDataSourceList {
999 return iter.page.Response()
1000 }
1001
1002
1003
1004 func (iter USQLExternalDataSourceListIterator) Value() USQLExternalDataSource {
1005 if !iter.page.NotDone() {
1006 return USQLExternalDataSource{}
1007 }
1008 return iter.page.Values()[iter.i]
1009 }
1010
1011
1012 func NewUSQLExternalDataSourceListIterator(page USQLExternalDataSourceListPage) USQLExternalDataSourceListIterator {
1013 return USQLExternalDataSourceListIterator{page: page}
1014 }
1015
1016
1017 func (usedsl USQLExternalDataSourceList) IsEmpty() bool {
1018 return usedsl.Value == nil || len(*usedsl.Value) == 0
1019 }
1020
1021
1022 func (usedsl USQLExternalDataSourceList) hasNextLink() bool {
1023 return usedsl.NextLink != nil && len(*usedsl.NextLink) != 0
1024 }
1025
1026
1027
1028 func (usedsl USQLExternalDataSourceList) uSQLExternalDataSourceListPreparer(ctx context.Context) (*http.Request, error) {
1029 if !usedsl.hasNextLink() {
1030 return nil, nil
1031 }
1032 return autorest.Prepare((&http.Request{}).WithContext(ctx),
1033 autorest.AsJSON(),
1034 autorest.AsGet(),
1035 autorest.WithBaseURL(to.String(usedsl.NextLink)))
1036 }
1037
1038
1039 type USQLExternalDataSourceListPage struct {
1040 fn func(context.Context, USQLExternalDataSourceList) (USQLExternalDataSourceList, error)
1041 uedsl USQLExternalDataSourceList
1042 }
1043
1044
1045
1046 func (page *USQLExternalDataSourceListPage) NextWithContext(ctx context.Context) (err error) {
1047 if tracing.IsEnabled() {
1048 ctx = tracing.StartSpan(ctx, fqdn+"/USQLExternalDataSourceListPage.NextWithContext")
1049 defer func() {
1050 sc := -1
1051 if page.Response().Response.Response != nil {
1052 sc = page.Response().Response.Response.StatusCode
1053 }
1054 tracing.EndSpan(ctx, sc, err)
1055 }()
1056 }
1057 for {
1058 next, err := page.fn(ctx, page.uedsl)
1059 if err != nil {
1060 return err
1061 }
1062 page.uedsl = next
1063 if !next.hasNextLink() || !next.IsEmpty() {
1064 break
1065 }
1066 }
1067 return nil
1068 }
1069
1070
1071
1072
1073 func (page *USQLExternalDataSourceListPage) Next() error {
1074 return page.NextWithContext(context.Background())
1075 }
1076
1077
1078 func (page USQLExternalDataSourceListPage) NotDone() bool {
1079 return !page.uedsl.IsEmpty()
1080 }
1081
1082
1083 func (page USQLExternalDataSourceListPage) Response() USQLExternalDataSourceList {
1084 return page.uedsl
1085 }
1086
1087
1088 func (page USQLExternalDataSourceListPage) Values() []USQLExternalDataSource {
1089 if page.uedsl.IsEmpty() {
1090 return nil
1091 }
1092 return *page.uedsl.Value
1093 }
1094
1095
1096 func NewUSQLExternalDataSourceListPage(cur USQLExternalDataSourceList, getNextPage func(context.Context, USQLExternalDataSourceList) (USQLExternalDataSourceList, error)) USQLExternalDataSourceListPage {
1097 return USQLExternalDataSourceListPage{
1098 fn: getNextPage,
1099 uedsl: cur,
1100 }
1101 }
1102
1103
1104 type USQLIndex struct {
1105
1106 Name *string `json:"name,omitempty"`
1107
1108 IndexKeys *[]USQLDirectedColumn `json:"indexKeys,omitempty"`
1109
1110 Columns *[]string `json:"columns,omitempty"`
1111
1112 DistributionInfo *USQLDistributionInfo `json:"distributionInfo,omitempty"`
1113
1114 PartitionFunction *uuid.UUID `json:"partitionFunction,omitempty"`
1115
1116 PartitionKeyList *[]string `json:"partitionKeyList,omitempty"`
1117
1118 StreamNames *[]string `json:"streamNames,omitempty"`
1119
1120 IsColumnstore *bool `json:"isColumnstore,omitempty"`
1121
1122 IndexID *int32 `json:"indexId,omitempty"`
1123
1124 IsUnique *bool `json:"isUnique,omitempty"`
1125 }
1126
1127
1128 type USQLPackage struct {
1129 autorest.Response `json:"-"`
1130
1131 DatabaseName *string `json:"databaseName,omitempty"`
1132
1133 SchemaName *string `json:"schemaName,omitempty"`
1134
1135 Name *string `json:"packageName,omitempty"`
1136
1137 Definition *string `json:"definition,omitempty"`
1138
1139 ComputeAccountName *string `json:"computeAccountName,omitempty"`
1140
1141 Version *uuid.UUID `json:"version,omitempty"`
1142 }
1143
1144
1145 type USQLPackageList struct {
1146 autorest.Response `json:"-"`
1147
1148 Value *[]USQLPackage `json:"value,omitempty"`
1149
1150 NextLink *string `json:"nextLink,omitempty"`
1151 }
1152
1153
1154 func (uspl USQLPackageList) MarshalJSON() ([]byte, error) {
1155 objectMap := make(map[string]interface{})
1156 if uspl.NextLink != nil {
1157 objectMap["nextLink"] = uspl.NextLink
1158 }
1159 return json.Marshal(objectMap)
1160 }
1161
1162
1163 type USQLPackageListIterator struct {
1164 i int
1165 page USQLPackageListPage
1166 }
1167
1168
1169
1170 func (iter *USQLPackageListIterator) NextWithContext(ctx context.Context) (err error) {
1171 if tracing.IsEnabled() {
1172 ctx = tracing.StartSpan(ctx, fqdn+"/USQLPackageListIterator.NextWithContext")
1173 defer func() {
1174 sc := -1
1175 if iter.Response().Response.Response != nil {
1176 sc = iter.Response().Response.Response.StatusCode
1177 }
1178 tracing.EndSpan(ctx, sc, err)
1179 }()
1180 }
1181 iter.i++
1182 if iter.i < len(iter.page.Values()) {
1183 return nil
1184 }
1185 err = iter.page.NextWithContext(ctx)
1186 if err != nil {
1187 iter.i--
1188 return err
1189 }
1190 iter.i = 0
1191 return nil
1192 }
1193
1194
1195
1196
1197 func (iter *USQLPackageListIterator) Next() error {
1198 return iter.NextWithContext(context.Background())
1199 }
1200
1201
1202 func (iter USQLPackageListIterator) NotDone() bool {
1203 return iter.page.NotDone() && iter.i < len(iter.page.Values())
1204 }
1205
1206
1207 func (iter USQLPackageListIterator) Response() USQLPackageList {
1208 return iter.page.Response()
1209 }
1210
1211
1212
1213 func (iter USQLPackageListIterator) Value() USQLPackage {
1214 if !iter.page.NotDone() {
1215 return USQLPackage{}
1216 }
1217 return iter.page.Values()[iter.i]
1218 }
1219
1220
1221 func NewUSQLPackageListIterator(page USQLPackageListPage) USQLPackageListIterator {
1222 return USQLPackageListIterator{page: page}
1223 }
1224
1225
1226 func (uspl USQLPackageList) IsEmpty() bool {
1227 return uspl.Value == nil || len(*uspl.Value) == 0
1228 }
1229
1230
1231 func (uspl USQLPackageList) hasNextLink() bool {
1232 return uspl.NextLink != nil && len(*uspl.NextLink) != 0
1233 }
1234
1235
1236
1237 func (uspl USQLPackageList) uSQLPackageListPreparer(ctx context.Context) (*http.Request, error) {
1238 if !uspl.hasNextLink() {
1239 return nil, nil
1240 }
1241 return autorest.Prepare((&http.Request{}).WithContext(ctx),
1242 autorest.AsJSON(),
1243 autorest.AsGet(),
1244 autorest.WithBaseURL(to.String(uspl.NextLink)))
1245 }
1246
1247
1248 type USQLPackageListPage struct {
1249 fn func(context.Context, USQLPackageList) (USQLPackageList, error)
1250 upl USQLPackageList
1251 }
1252
1253
1254
1255 func (page *USQLPackageListPage) NextWithContext(ctx context.Context) (err error) {
1256 if tracing.IsEnabled() {
1257 ctx = tracing.StartSpan(ctx, fqdn+"/USQLPackageListPage.NextWithContext")
1258 defer func() {
1259 sc := -1
1260 if page.Response().Response.Response != nil {
1261 sc = page.Response().Response.Response.StatusCode
1262 }
1263 tracing.EndSpan(ctx, sc, err)
1264 }()
1265 }
1266 for {
1267 next, err := page.fn(ctx, page.upl)
1268 if err != nil {
1269 return err
1270 }
1271 page.upl = next
1272 if !next.hasNextLink() || !next.IsEmpty() {
1273 break
1274 }
1275 }
1276 return nil
1277 }
1278
1279
1280
1281
1282 func (page *USQLPackageListPage) Next() error {
1283 return page.NextWithContext(context.Background())
1284 }
1285
1286
1287 func (page USQLPackageListPage) NotDone() bool {
1288 return !page.upl.IsEmpty()
1289 }
1290
1291
1292 func (page USQLPackageListPage) Response() USQLPackageList {
1293 return page.upl
1294 }
1295
1296
1297 func (page USQLPackageListPage) Values() []USQLPackage {
1298 if page.upl.IsEmpty() {
1299 return nil
1300 }
1301 return *page.upl.Value
1302 }
1303
1304
1305 func NewUSQLPackageListPage(cur USQLPackageList, getNextPage func(context.Context, USQLPackageList) (USQLPackageList, error)) USQLPackageListPage {
1306 return USQLPackageListPage{
1307 fn: getNextPage,
1308 upl: cur,
1309 }
1310 }
1311
1312
1313 type USQLProcedure struct {
1314 autorest.Response `json:"-"`
1315
1316 DatabaseName *string `json:"databaseName,omitempty"`
1317
1318 SchemaName *string `json:"schemaName,omitempty"`
1319
1320 Name *string `json:"procName,omitempty"`
1321
1322 Definition *string `json:"definition,omitempty"`
1323
1324 ComputeAccountName *string `json:"computeAccountName,omitempty"`
1325
1326 Version *uuid.UUID `json:"version,omitempty"`
1327 }
1328
1329
1330 type USQLProcedureList struct {
1331 autorest.Response `json:"-"`
1332
1333 Value *[]USQLProcedure `json:"value,omitempty"`
1334
1335 NextLink *string `json:"nextLink,omitempty"`
1336 }
1337
1338
1339 func (uspl USQLProcedureList) MarshalJSON() ([]byte, error) {
1340 objectMap := make(map[string]interface{})
1341 if uspl.NextLink != nil {
1342 objectMap["nextLink"] = uspl.NextLink
1343 }
1344 return json.Marshal(objectMap)
1345 }
1346
1347
1348 type USQLProcedureListIterator struct {
1349 i int
1350 page USQLProcedureListPage
1351 }
1352
1353
1354
1355 func (iter *USQLProcedureListIterator) NextWithContext(ctx context.Context) (err error) {
1356 if tracing.IsEnabled() {
1357 ctx = tracing.StartSpan(ctx, fqdn+"/USQLProcedureListIterator.NextWithContext")
1358 defer func() {
1359 sc := -1
1360 if iter.Response().Response.Response != nil {
1361 sc = iter.Response().Response.Response.StatusCode
1362 }
1363 tracing.EndSpan(ctx, sc, err)
1364 }()
1365 }
1366 iter.i++
1367 if iter.i < len(iter.page.Values()) {
1368 return nil
1369 }
1370 err = iter.page.NextWithContext(ctx)
1371 if err != nil {
1372 iter.i--
1373 return err
1374 }
1375 iter.i = 0
1376 return nil
1377 }
1378
1379
1380
1381
1382 func (iter *USQLProcedureListIterator) Next() error {
1383 return iter.NextWithContext(context.Background())
1384 }
1385
1386
1387 func (iter USQLProcedureListIterator) NotDone() bool {
1388 return iter.page.NotDone() && iter.i < len(iter.page.Values())
1389 }
1390
1391
1392 func (iter USQLProcedureListIterator) Response() USQLProcedureList {
1393 return iter.page.Response()
1394 }
1395
1396
1397
1398 func (iter USQLProcedureListIterator) Value() USQLProcedure {
1399 if !iter.page.NotDone() {
1400 return USQLProcedure{}
1401 }
1402 return iter.page.Values()[iter.i]
1403 }
1404
1405
1406 func NewUSQLProcedureListIterator(page USQLProcedureListPage) USQLProcedureListIterator {
1407 return USQLProcedureListIterator{page: page}
1408 }
1409
1410
1411 func (uspl USQLProcedureList) IsEmpty() bool {
1412 return uspl.Value == nil || len(*uspl.Value) == 0
1413 }
1414
1415
1416 func (uspl USQLProcedureList) hasNextLink() bool {
1417 return uspl.NextLink != nil && len(*uspl.NextLink) != 0
1418 }
1419
1420
1421
1422 func (uspl USQLProcedureList) uSQLProcedureListPreparer(ctx context.Context) (*http.Request, error) {
1423 if !uspl.hasNextLink() {
1424 return nil, nil
1425 }
1426 return autorest.Prepare((&http.Request{}).WithContext(ctx),
1427 autorest.AsJSON(),
1428 autorest.AsGet(),
1429 autorest.WithBaseURL(to.String(uspl.NextLink)))
1430 }
1431
1432
1433 type USQLProcedureListPage struct {
1434 fn func(context.Context, USQLProcedureList) (USQLProcedureList, error)
1435 upl USQLProcedureList
1436 }
1437
1438
1439
1440 func (page *USQLProcedureListPage) NextWithContext(ctx context.Context) (err error) {
1441 if tracing.IsEnabled() {
1442 ctx = tracing.StartSpan(ctx, fqdn+"/USQLProcedureListPage.NextWithContext")
1443 defer func() {
1444 sc := -1
1445 if page.Response().Response.Response != nil {
1446 sc = page.Response().Response.Response.StatusCode
1447 }
1448 tracing.EndSpan(ctx, sc, err)
1449 }()
1450 }
1451 for {
1452 next, err := page.fn(ctx, page.upl)
1453 if err != nil {
1454 return err
1455 }
1456 page.upl = next
1457 if !next.hasNextLink() || !next.IsEmpty() {
1458 break
1459 }
1460 }
1461 return nil
1462 }
1463
1464
1465
1466
1467 func (page *USQLProcedureListPage) Next() error {
1468 return page.NextWithContext(context.Background())
1469 }
1470
1471
1472 func (page USQLProcedureListPage) NotDone() bool {
1473 return !page.upl.IsEmpty()
1474 }
1475
1476
1477 func (page USQLProcedureListPage) Response() USQLProcedureList {
1478 return page.upl
1479 }
1480
1481
1482 func (page USQLProcedureListPage) Values() []USQLProcedure {
1483 if page.upl.IsEmpty() {
1484 return nil
1485 }
1486 return *page.upl.Value
1487 }
1488
1489
1490 func NewUSQLProcedureListPage(cur USQLProcedureList, getNextPage func(context.Context, USQLProcedureList) (USQLProcedureList, error)) USQLProcedureListPage {
1491 return USQLProcedureListPage{
1492 fn: getNextPage,
1493 upl: cur,
1494 }
1495 }
1496
1497
1498 type USQLSchema struct {
1499 autorest.Response `json:"-"`
1500
1501 DatabaseName *string `json:"databaseName,omitempty"`
1502
1503 Name *string `json:"schemaName,omitempty"`
1504
1505 ComputeAccountName *string `json:"computeAccountName,omitempty"`
1506
1507 Version *uuid.UUID `json:"version,omitempty"`
1508 }
1509
1510
1511 type USQLSchemaList struct {
1512 autorest.Response `json:"-"`
1513
1514 Value *[]USQLSchema `json:"value,omitempty"`
1515
1516 NextLink *string `json:"nextLink,omitempty"`
1517 }
1518
1519
1520 func (ussl USQLSchemaList) MarshalJSON() ([]byte, error) {
1521 objectMap := make(map[string]interface{})
1522 if ussl.NextLink != nil {
1523 objectMap["nextLink"] = ussl.NextLink
1524 }
1525 return json.Marshal(objectMap)
1526 }
1527
1528
1529 type USQLSchemaListIterator struct {
1530 i int
1531 page USQLSchemaListPage
1532 }
1533
1534
1535
1536 func (iter *USQLSchemaListIterator) NextWithContext(ctx context.Context) (err error) {
1537 if tracing.IsEnabled() {
1538 ctx = tracing.StartSpan(ctx, fqdn+"/USQLSchemaListIterator.NextWithContext")
1539 defer func() {
1540 sc := -1
1541 if iter.Response().Response.Response != nil {
1542 sc = iter.Response().Response.Response.StatusCode
1543 }
1544 tracing.EndSpan(ctx, sc, err)
1545 }()
1546 }
1547 iter.i++
1548 if iter.i < len(iter.page.Values()) {
1549 return nil
1550 }
1551 err = iter.page.NextWithContext(ctx)
1552 if err != nil {
1553 iter.i--
1554 return err
1555 }
1556 iter.i = 0
1557 return nil
1558 }
1559
1560
1561
1562
1563 func (iter *USQLSchemaListIterator) Next() error {
1564 return iter.NextWithContext(context.Background())
1565 }
1566
1567
1568 func (iter USQLSchemaListIterator) NotDone() bool {
1569 return iter.page.NotDone() && iter.i < len(iter.page.Values())
1570 }
1571
1572
1573 func (iter USQLSchemaListIterator) Response() USQLSchemaList {
1574 return iter.page.Response()
1575 }
1576
1577
1578
1579 func (iter USQLSchemaListIterator) Value() USQLSchema {
1580 if !iter.page.NotDone() {
1581 return USQLSchema{}
1582 }
1583 return iter.page.Values()[iter.i]
1584 }
1585
1586
1587 func NewUSQLSchemaListIterator(page USQLSchemaListPage) USQLSchemaListIterator {
1588 return USQLSchemaListIterator{page: page}
1589 }
1590
1591
1592 func (ussl USQLSchemaList) IsEmpty() bool {
1593 return ussl.Value == nil || len(*ussl.Value) == 0
1594 }
1595
1596
1597 func (ussl USQLSchemaList) hasNextLink() bool {
1598 return ussl.NextLink != nil && len(*ussl.NextLink) != 0
1599 }
1600
1601
1602
1603 func (ussl USQLSchemaList) uSQLSchemaListPreparer(ctx context.Context) (*http.Request, error) {
1604 if !ussl.hasNextLink() {
1605 return nil, nil
1606 }
1607 return autorest.Prepare((&http.Request{}).WithContext(ctx),
1608 autorest.AsJSON(),
1609 autorest.AsGet(),
1610 autorest.WithBaseURL(to.String(ussl.NextLink)))
1611 }
1612
1613
1614 type USQLSchemaListPage struct {
1615 fn func(context.Context, USQLSchemaList) (USQLSchemaList, error)
1616 usl USQLSchemaList
1617 }
1618
1619
1620
1621 func (page *USQLSchemaListPage) NextWithContext(ctx context.Context) (err error) {
1622 if tracing.IsEnabled() {
1623 ctx = tracing.StartSpan(ctx, fqdn+"/USQLSchemaListPage.NextWithContext")
1624 defer func() {
1625 sc := -1
1626 if page.Response().Response.Response != nil {
1627 sc = page.Response().Response.Response.StatusCode
1628 }
1629 tracing.EndSpan(ctx, sc, err)
1630 }()
1631 }
1632 for {
1633 next, err := page.fn(ctx, page.usl)
1634 if err != nil {
1635 return err
1636 }
1637 page.usl = next
1638 if !next.hasNextLink() || !next.IsEmpty() {
1639 break
1640 }
1641 }
1642 return nil
1643 }
1644
1645
1646
1647
1648 func (page *USQLSchemaListPage) Next() error {
1649 return page.NextWithContext(context.Background())
1650 }
1651
1652
1653 func (page USQLSchemaListPage) NotDone() bool {
1654 return !page.usl.IsEmpty()
1655 }
1656
1657
1658 func (page USQLSchemaListPage) Response() USQLSchemaList {
1659 return page.usl
1660 }
1661
1662
1663 func (page USQLSchemaListPage) Values() []USQLSchema {
1664 if page.usl.IsEmpty() {
1665 return nil
1666 }
1667 return *page.usl.Value
1668 }
1669
1670
1671 func NewUSQLSchemaListPage(cur USQLSchemaList, getNextPage func(context.Context, USQLSchemaList) (USQLSchemaList, error)) USQLSchemaListPage {
1672 return USQLSchemaListPage{
1673 fn: getNextPage,
1674 usl: cur,
1675 }
1676 }
1677
1678
1679 type USQLSecret struct {
1680 autorest.Response `json:"-"`
1681
1682 DatabaseName *string `json:"databaseName,omitempty"`
1683
1684 Name *string `json:"secretName,omitempty"`
1685
1686 CreationTime *date.Time `json:"creationTime,omitempty"`
1687
1688 URI *string `json:"uri,omitempty"`
1689
1690 Password *string `json:"password,omitempty"`
1691
1692 ComputeAccountName *string `json:"computeAccountName,omitempty"`
1693
1694 Version *uuid.UUID `json:"version,omitempty"`
1695 }
1696
1697
1698 type USQLTable struct {
1699 autorest.Response `json:"-"`
1700
1701 DatabaseName *string `json:"databaseName,omitempty"`
1702
1703 SchemaName *string `json:"schemaName,omitempty"`
1704
1705 Name *string `json:"tableName,omitempty"`
1706
1707 ColumnList *[]USQLTableColumn `json:"columnList,omitempty"`
1708
1709 IndexList *[]USQLIndex `json:"indexList,omitempty"`
1710
1711 PartitionKeyList *[]string `json:"partitionKeyList,omitempty"`
1712
1713 ExternalTable *ExternalTable `json:"externalTable,omitempty"`
1714
1715 DistributionInfo *USQLDistributionInfo `json:"distributionInfo,omitempty"`
1716
1717 ComputeAccountName *string `json:"computeAccountName,omitempty"`
1718
1719 Version *uuid.UUID `json:"version,omitempty"`
1720 }
1721
1722
1723 type USQLTableColumn struct {
1724
1725 Name *string `json:"name,omitempty"`
1726
1727 Type *string `json:"type,omitempty"`
1728 }
1729
1730
1731 type USQLTableFragment struct {
1732
1733 ParentID *uuid.UUID `json:"parentId,omitempty"`
1734
1735 FragmentID *uuid.UUID `json:"fragmentId,omitempty"`
1736
1737 IndexID *int32 `json:"indexId,omitempty"`
1738
1739 Size *int64 `json:"size,omitempty"`
1740
1741 RowCount *int64 `json:"rowCount,omitempty"`
1742
1743 CreateDate *date.Time `json:"createDate,omitempty"`
1744
1745 StreamPath *string `json:"streamPath,omitempty"`
1746 }
1747
1748
1749 type USQLTableFragmentList struct {
1750 autorest.Response `json:"-"`
1751
1752 Value *[]USQLTableFragment `json:"value,omitempty"`
1753
1754 NextLink *string `json:"nextLink,omitempty"`
1755 }
1756
1757
1758 func (ustfl USQLTableFragmentList) MarshalJSON() ([]byte, error) {
1759 objectMap := make(map[string]interface{})
1760 if ustfl.NextLink != nil {
1761 objectMap["nextLink"] = ustfl.NextLink
1762 }
1763 return json.Marshal(objectMap)
1764 }
1765
1766
1767 type USQLTableFragmentListIterator struct {
1768 i int
1769 page USQLTableFragmentListPage
1770 }
1771
1772
1773
1774 func (iter *USQLTableFragmentListIterator) NextWithContext(ctx context.Context) (err error) {
1775 if tracing.IsEnabled() {
1776 ctx = tracing.StartSpan(ctx, fqdn+"/USQLTableFragmentListIterator.NextWithContext")
1777 defer func() {
1778 sc := -1
1779 if iter.Response().Response.Response != nil {
1780 sc = iter.Response().Response.Response.StatusCode
1781 }
1782 tracing.EndSpan(ctx, sc, err)
1783 }()
1784 }
1785 iter.i++
1786 if iter.i < len(iter.page.Values()) {
1787 return nil
1788 }
1789 err = iter.page.NextWithContext(ctx)
1790 if err != nil {
1791 iter.i--
1792 return err
1793 }
1794 iter.i = 0
1795 return nil
1796 }
1797
1798
1799
1800
1801 func (iter *USQLTableFragmentListIterator) Next() error {
1802 return iter.NextWithContext(context.Background())
1803 }
1804
1805
1806 func (iter USQLTableFragmentListIterator) NotDone() bool {
1807 return iter.page.NotDone() && iter.i < len(iter.page.Values())
1808 }
1809
1810
1811 func (iter USQLTableFragmentListIterator) Response() USQLTableFragmentList {
1812 return iter.page.Response()
1813 }
1814
1815
1816
1817 func (iter USQLTableFragmentListIterator) Value() USQLTableFragment {
1818 if !iter.page.NotDone() {
1819 return USQLTableFragment{}
1820 }
1821 return iter.page.Values()[iter.i]
1822 }
1823
1824
1825 func NewUSQLTableFragmentListIterator(page USQLTableFragmentListPage) USQLTableFragmentListIterator {
1826 return USQLTableFragmentListIterator{page: page}
1827 }
1828
1829
1830 func (ustfl USQLTableFragmentList) IsEmpty() bool {
1831 return ustfl.Value == nil || len(*ustfl.Value) == 0
1832 }
1833
1834
1835 func (ustfl USQLTableFragmentList) hasNextLink() bool {
1836 return ustfl.NextLink != nil && len(*ustfl.NextLink) != 0
1837 }
1838
1839
1840
1841 func (ustfl USQLTableFragmentList) uSQLTableFragmentListPreparer(ctx context.Context) (*http.Request, error) {
1842 if !ustfl.hasNextLink() {
1843 return nil, nil
1844 }
1845 return autorest.Prepare((&http.Request{}).WithContext(ctx),
1846 autorest.AsJSON(),
1847 autorest.AsGet(),
1848 autorest.WithBaseURL(to.String(ustfl.NextLink)))
1849 }
1850
1851
1852 type USQLTableFragmentListPage struct {
1853 fn func(context.Context, USQLTableFragmentList) (USQLTableFragmentList, error)
1854 utfl USQLTableFragmentList
1855 }
1856
1857
1858
1859 func (page *USQLTableFragmentListPage) NextWithContext(ctx context.Context) (err error) {
1860 if tracing.IsEnabled() {
1861 ctx = tracing.StartSpan(ctx, fqdn+"/USQLTableFragmentListPage.NextWithContext")
1862 defer func() {
1863 sc := -1
1864 if page.Response().Response.Response != nil {
1865 sc = page.Response().Response.Response.StatusCode
1866 }
1867 tracing.EndSpan(ctx, sc, err)
1868 }()
1869 }
1870 for {
1871 next, err := page.fn(ctx, page.utfl)
1872 if err != nil {
1873 return err
1874 }
1875 page.utfl = next
1876 if !next.hasNextLink() || !next.IsEmpty() {
1877 break
1878 }
1879 }
1880 return nil
1881 }
1882
1883
1884
1885
1886 func (page *USQLTableFragmentListPage) Next() error {
1887 return page.NextWithContext(context.Background())
1888 }
1889
1890
1891 func (page USQLTableFragmentListPage) NotDone() bool {
1892 return !page.utfl.IsEmpty()
1893 }
1894
1895
1896 func (page USQLTableFragmentListPage) Response() USQLTableFragmentList {
1897 return page.utfl
1898 }
1899
1900
1901 func (page USQLTableFragmentListPage) Values() []USQLTableFragment {
1902 if page.utfl.IsEmpty() {
1903 return nil
1904 }
1905 return *page.utfl.Value
1906 }
1907
1908
1909 func NewUSQLTableFragmentListPage(cur USQLTableFragmentList, getNextPage func(context.Context, USQLTableFragmentList) (USQLTableFragmentList, error)) USQLTableFragmentListPage {
1910 return USQLTableFragmentListPage{
1911 fn: getNextPage,
1912 utfl: cur,
1913 }
1914 }
1915
1916
1917 type USQLTableList struct {
1918 autorest.Response `json:"-"`
1919
1920 Value *[]USQLTable `json:"value,omitempty"`
1921
1922 NextLink *string `json:"nextLink,omitempty"`
1923 }
1924
1925
1926 func (ustl USQLTableList) MarshalJSON() ([]byte, error) {
1927 objectMap := make(map[string]interface{})
1928 if ustl.NextLink != nil {
1929 objectMap["nextLink"] = ustl.NextLink
1930 }
1931 return json.Marshal(objectMap)
1932 }
1933
1934
1935 type USQLTableListIterator struct {
1936 i int
1937 page USQLTableListPage
1938 }
1939
1940
1941
1942 func (iter *USQLTableListIterator) NextWithContext(ctx context.Context) (err error) {
1943 if tracing.IsEnabled() {
1944 ctx = tracing.StartSpan(ctx, fqdn+"/USQLTableListIterator.NextWithContext")
1945 defer func() {
1946 sc := -1
1947 if iter.Response().Response.Response != nil {
1948 sc = iter.Response().Response.Response.StatusCode
1949 }
1950 tracing.EndSpan(ctx, sc, err)
1951 }()
1952 }
1953 iter.i++
1954 if iter.i < len(iter.page.Values()) {
1955 return nil
1956 }
1957 err = iter.page.NextWithContext(ctx)
1958 if err != nil {
1959 iter.i--
1960 return err
1961 }
1962 iter.i = 0
1963 return nil
1964 }
1965
1966
1967
1968
1969 func (iter *USQLTableListIterator) Next() error {
1970 return iter.NextWithContext(context.Background())
1971 }
1972
1973
1974 func (iter USQLTableListIterator) NotDone() bool {
1975 return iter.page.NotDone() && iter.i < len(iter.page.Values())
1976 }
1977
1978
1979 func (iter USQLTableListIterator) Response() USQLTableList {
1980 return iter.page.Response()
1981 }
1982
1983
1984
1985 func (iter USQLTableListIterator) Value() USQLTable {
1986 if !iter.page.NotDone() {
1987 return USQLTable{}
1988 }
1989 return iter.page.Values()[iter.i]
1990 }
1991
1992
1993 func NewUSQLTableListIterator(page USQLTableListPage) USQLTableListIterator {
1994 return USQLTableListIterator{page: page}
1995 }
1996
1997
1998 func (ustl USQLTableList) IsEmpty() bool {
1999 return ustl.Value == nil || len(*ustl.Value) == 0
2000 }
2001
2002
2003 func (ustl USQLTableList) hasNextLink() bool {
2004 return ustl.NextLink != nil && len(*ustl.NextLink) != 0
2005 }
2006
2007
2008
2009 func (ustl USQLTableList) uSQLTableListPreparer(ctx context.Context) (*http.Request, error) {
2010 if !ustl.hasNextLink() {
2011 return nil, nil
2012 }
2013 return autorest.Prepare((&http.Request{}).WithContext(ctx),
2014 autorest.AsJSON(),
2015 autorest.AsGet(),
2016 autorest.WithBaseURL(to.String(ustl.NextLink)))
2017 }
2018
2019
2020 type USQLTableListPage struct {
2021 fn func(context.Context, USQLTableList) (USQLTableList, error)
2022 utl USQLTableList
2023 }
2024
2025
2026
2027 func (page *USQLTableListPage) NextWithContext(ctx context.Context) (err error) {
2028 if tracing.IsEnabled() {
2029 ctx = tracing.StartSpan(ctx, fqdn+"/USQLTableListPage.NextWithContext")
2030 defer func() {
2031 sc := -1
2032 if page.Response().Response.Response != nil {
2033 sc = page.Response().Response.Response.StatusCode
2034 }
2035 tracing.EndSpan(ctx, sc, err)
2036 }()
2037 }
2038 for {
2039 next, err := page.fn(ctx, page.utl)
2040 if err != nil {
2041 return err
2042 }
2043 page.utl = next
2044 if !next.hasNextLink() || !next.IsEmpty() {
2045 break
2046 }
2047 }
2048 return nil
2049 }
2050
2051
2052
2053
2054 func (page *USQLTableListPage) Next() error {
2055 return page.NextWithContext(context.Background())
2056 }
2057
2058
2059 func (page USQLTableListPage) NotDone() bool {
2060 return !page.utl.IsEmpty()
2061 }
2062
2063
2064 func (page USQLTableListPage) Response() USQLTableList {
2065 return page.utl
2066 }
2067
2068
2069 func (page USQLTableListPage) Values() []USQLTable {
2070 if page.utl.IsEmpty() {
2071 return nil
2072 }
2073 return *page.utl.Value
2074 }
2075
2076
2077 func NewUSQLTableListPage(cur USQLTableList, getNextPage func(context.Context, USQLTableList) (USQLTableList, error)) USQLTableListPage {
2078 return USQLTableListPage{
2079 fn: getNextPage,
2080 utl: cur,
2081 }
2082 }
2083
2084
2085 type USQLTablePartition struct {
2086 autorest.Response `json:"-"`
2087
2088 DatabaseName *string `json:"databaseName,omitempty"`
2089
2090 SchemaName *string `json:"schemaName,omitempty"`
2091
2092 Name *string `json:"partitionName,omitempty"`
2093
2094 ParentName *DdlName `json:"parentName,omitempty"`
2095
2096 IndexID *int32 `json:"indexId,omitempty"`
2097
2098 Label *[]string `json:"label,omitempty"`
2099
2100 CreateDate *date.Time `json:"createDate,omitempty"`
2101
2102 ComputeAccountName *string `json:"computeAccountName,omitempty"`
2103
2104 Version *uuid.UUID `json:"version,omitempty"`
2105 }
2106
2107
2108 type USQLTablePartitionList struct {
2109 autorest.Response `json:"-"`
2110
2111 Value *[]USQLTablePartition `json:"value,omitempty"`
2112
2113 NextLink *string `json:"nextLink,omitempty"`
2114 }
2115
2116
2117 func (ustpl USQLTablePartitionList) MarshalJSON() ([]byte, error) {
2118 objectMap := make(map[string]interface{})
2119 if ustpl.NextLink != nil {
2120 objectMap["nextLink"] = ustpl.NextLink
2121 }
2122 return json.Marshal(objectMap)
2123 }
2124
2125
2126 type USQLTablePartitionListIterator struct {
2127 i int
2128 page USQLTablePartitionListPage
2129 }
2130
2131
2132
2133 func (iter *USQLTablePartitionListIterator) NextWithContext(ctx context.Context) (err error) {
2134 if tracing.IsEnabled() {
2135 ctx = tracing.StartSpan(ctx, fqdn+"/USQLTablePartitionListIterator.NextWithContext")
2136 defer func() {
2137 sc := -1
2138 if iter.Response().Response.Response != nil {
2139 sc = iter.Response().Response.Response.StatusCode
2140 }
2141 tracing.EndSpan(ctx, sc, err)
2142 }()
2143 }
2144 iter.i++
2145 if iter.i < len(iter.page.Values()) {
2146 return nil
2147 }
2148 err = iter.page.NextWithContext(ctx)
2149 if err != nil {
2150 iter.i--
2151 return err
2152 }
2153 iter.i = 0
2154 return nil
2155 }
2156
2157
2158
2159
2160 func (iter *USQLTablePartitionListIterator) Next() error {
2161 return iter.NextWithContext(context.Background())
2162 }
2163
2164
2165 func (iter USQLTablePartitionListIterator) NotDone() bool {
2166 return iter.page.NotDone() && iter.i < len(iter.page.Values())
2167 }
2168
2169
2170 func (iter USQLTablePartitionListIterator) Response() USQLTablePartitionList {
2171 return iter.page.Response()
2172 }
2173
2174
2175
2176 func (iter USQLTablePartitionListIterator) Value() USQLTablePartition {
2177 if !iter.page.NotDone() {
2178 return USQLTablePartition{}
2179 }
2180 return iter.page.Values()[iter.i]
2181 }
2182
2183
2184 func NewUSQLTablePartitionListIterator(page USQLTablePartitionListPage) USQLTablePartitionListIterator {
2185 return USQLTablePartitionListIterator{page: page}
2186 }
2187
2188
2189 func (ustpl USQLTablePartitionList) IsEmpty() bool {
2190 return ustpl.Value == nil || len(*ustpl.Value) == 0
2191 }
2192
2193
2194 func (ustpl USQLTablePartitionList) hasNextLink() bool {
2195 return ustpl.NextLink != nil && len(*ustpl.NextLink) != 0
2196 }
2197
2198
2199
2200 func (ustpl USQLTablePartitionList) uSQLTablePartitionListPreparer(ctx context.Context) (*http.Request, error) {
2201 if !ustpl.hasNextLink() {
2202 return nil, nil
2203 }
2204 return autorest.Prepare((&http.Request{}).WithContext(ctx),
2205 autorest.AsJSON(),
2206 autorest.AsGet(),
2207 autorest.WithBaseURL(to.String(ustpl.NextLink)))
2208 }
2209
2210
2211 type USQLTablePartitionListPage struct {
2212 fn func(context.Context, USQLTablePartitionList) (USQLTablePartitionList, error)
2213 utpl USQLTablePartitionList
2214 }
2215
2216
2217
2218 func (page *USQLTablePartitionListPage) NextWithContext(ctx context.Context) (err error) {
2219 if tracing.IsEnabled() {
2220 ctx = tracing.StartSpan(ctx, fqdn+"/USQLTablePartitionListPage.NextWithContext")
2221 defer func() {
2222 sc := -1
2223 if page.Response().Response.Response != nil {
2224 sc = page.Response().Response.Response.StatusCode
2225 }
2226 tracing.EndSpan(ctx, sc, err)
2227 }()
2228 }
2229 for {
2230 next, err := page.fn(ctx, page.utpl)
2231 if err != nil {
2232 return err
2233 }
2234 page.utpl = next
2235 if !next.hasNextLink() || !next.IsEmpty() {
2236 break
2237 }
2238 }
2239 return nil
2240 }
2241
2242
2243
2244
2245 func (page *USQLTablePartitionListPage) Next() error {
2246 return page.NextWithContext(context.Background())
2247 }
2248
2249
2250 func (page USQLTablePartitionListPage) NotDone() bool {
2251 return !page.utpl.IsEmpty()
2252 }
2253
2254
2255 func (page USQLTablePartitionListPage) Response() USQLTablePartitionList {
2256 return page.utpl
2257 }
2258
2259
2260 func (page USQLTablePartitionListPage) Values() []USQLTablePartition {
2261 if page.utpl.IsEmpty() {
2262 return nil
2263 }
2264 return *page.utpl.Value
2265 }
2266
2267
2268 func NewUSQLTablePartitionListPage(cur USQLTablePartitionList, getNextPage func(context.Context, USQLTablePartitionList) (USQLTablePartitionList, error)) USQLTablePartitionListPage {
2269 return USQLTablePartitionListPage{
2270 fn: getNextPage,
2271 utpl: cur,
2272 }
2273 }
2274
2275
2276 type USQLTablePreview struct {
2277 autorest.Response `json:"-"`
2278
2279 TotalRowCount *int64 `json:"totalRowCount,omitempty"`
2280
2281 TotalColumnCount *int64 `json:"totalColumnCount,omitempty"`
2282
2283 Rows *[][]string `json:"rows,omitempty"`
2284
2285 Truncated *bool `json:"truncated,omitempty"`
2286
2287 Schema *[]USQLTableColumn `json:"schema,omitempty"`
2288 }
2289
2290
2291 type USQLTableStatistics struct {
2292 autorest.Response `json:"-"`
2293
2294 DatabaseName *string `json:"databaseName,omitempty"`
2295
2296 SchemaName *string `json:"schemaName,omitempty"`
2297
2298 TableName *string `json:"tableName,omitempty"`
2299
2300 Name *string `json:"statisticsName,omitempty"`
2301
2302 UserStatName *string `json:"userStatName,omitempty"`
2303
2304 StatDataPath *string `json:"statDataPath,omitempty"`
2305
2306 CreateTime *date.Time `json:"createTime,omitempty"`
2307
2308 UpdateTime *date.Time `json:"updateTime,omitempty"`
2309
2310 IsUserCreated *bool `json:"isUserCreated,omitempty"`
2311
2312 IsAutoCreated *bool `json:"isAutoCreated,omitempty"`
2313
2314 HasFilter *bool `json:"hasFilter,omitempty"`
2315
2316 FilterDefinition *string `json:"filterDefinition,omitempty"`
2317
2318 ColNames *[]string `json:"colNames,omitempty"`
2319
2320 ComputeAccountName *string `json:"computeAccountName,omitempty"`
2321
2322 Version *uuid.UUID `json:"version,omitempty"`
2323 }
2324
2325
2326 type USQLTableStatisticsList struct {
2327 autorest.Response `json:"-"`
2328
2329 Value *[]USQLTableStatistics `json:"value,omitempty"`
2330
2331 NextLink *string `json:"nextLink,omitempty"`
2332 }
2333
2334
2335 func (ustsl USQLTableStatisticsList) MarshalJSON() ([]byte, error) {
2336 objectMap := make(map[string]interface{})
2337 if ustsl.NextLink != nil {
2338 objectMap["nextLink"] = ustsl.NextLink
2339 }
2340 return json.Marshal(objectMap)
2341 }
2342
2343
2344 type USQLTableStatisticsListIterator struct {
2345 i int
2346 page USQLTableStatisticsListPage
2347 }
2348
2349
2350
2351 func (iter *USQLTableStatisticsListIterator) NextWithContext(ctx context.Context) (err error) {
2352 if tracing.IsEnabled() {
2353 ctx = tracing.StartSpan(ctx, fqdn+"/USQLTableStatisticsListIterator.NextWithContext")
2354 defer func() {
2355 sc := -1
2356 if iter.Response().Response.Response != nil {
2357 sc = iter.Response().Response.Response.StatusCode
2358 }
2359 tracing.EndSpan(ctx, sc, err)
2360 }()
2361 }
2362 iter.i++
2363 if iter.i < len(iter.page.Values()) {
2364 return nil
2365 }
2366 err = iter.page.NextWithContext(ctx)
2367 if err != nil {
2368 iter.i--
2369 return err
2370 }
2371 iter.i = 0
2372 return nil
2373 }
2374
2375
2376
2377
2378 func (iter *USQLTableStatisticsListIterator) Next() error {
2379 return iter.NextWithContext(context.Background())
2380 }
2381
2382
2383 func (iter USQLTableStatisticsListIterator) NotDone() bool {
2384 return iter.page.NotDone() && iter.i < len(iter.page.Values())
2385 }
2386
2387
2388 func (iter USQLTableStatisticsListIterator) Response() USQLTableStatisticsList {
2389 return iter.page.Response()
2390 }
2391
2392
2393
2394 func (iter USQLTableStatisticsListIterator) Value() USQLTableStatistics {
2395 if !iter.page.NotDone() {
2396 return USQLTableStatistics{}
2397 }
2398 return iter.page.Values()[iter.i]
2399 }
2400
2401
2402 func NewUSQLTableStatisticsListIterator(page USQLTableStatisticsListPage) USQLTableStatisticsListIterator {
2403 return USQLTableStatisticsListIterator{page: page}
2404 }
2405
2406
2407 func (ustsl USQLTableStatisticsList) IsEmpty() bool {
2408 return ustsl.Value == nil || len(*ustsl.Value) == 0
2409 }
2410
2411
2412 func (ustsl USQLTableStatisticsList) hasNextLink() bool {
2413 return ustsl.NextLink != nil && len(*ustsl.NextLink) != 0
2414 }
2415
2416
2417
2418 func (ustsl USQLTableStatisticsList) uSQLTableStatisticsListPreparer(ctx context.Context) (*http.Request, error) {
2419 if !ustsl.hasNextLink() {
2420 return nil, nil
2421 }
2422 return autorest.Prepare((&http.Request{}).WithContext(ctx),
2423 autorest.AsJSON(),
2424 autorest.AsGet(),
2425 autorest.WithBaseURL(to.String(ustsl.NextLink)))
2426 }
2427
2428
2429 type USQLTableStatisticsListPage struct {
2430 fn func(context.Context, USQLTableStatisticsList) (USQLTableStatisticsList, error)
2431 utsl USQLTableStatisticsList
2432 }
2433
2434
2435
2436 func (page *USQLTableStatisticsListPage) NextWithContext(ctx context.Context) (err error) {
2437 if tracing.IsEnabled() {
2438 ctx = tracing.StartSpan(ctx, fqdn+"/USQLTableStatisticsListPage.NextWithContext")
2439 defer func() {
2440 sc := -1
2441 if page.Response().Response.Response != nil {
2442 sc = page.Response().Response.Response.StatusCode
2443 }
2444 tracing.EndSpan(ctx, sc, err)
2445 }()
2446 }
2447 for {
2448 next, err := page.fn(ctx, page.utsl)
2449 if err != nil {
2450 return err
2451 }
2452 page.utsl = next
2453 if !next.hasNextLink() || !next.IsEmpty() {
2454 break
2455 }
2456 }
2457 return nil
2458 }
2459
2460
2461
2462
2463 func (page *USQLTableStatisticsListPage) Next() error {
2464 return page.NextWithContext(context.Background())
2465 }
2466
2467
2468 func (page USQLTableStatisticsListPage) NotDone() bool {
2469 return !page.utsl.IsEmpty()
2470 }
2471
2472
2473 func (page USQLTableStatisticsListPage) Response() USQLTableStatisticsList {
2474 return page.utsl
2475 }
2476
2477
2478 func (page USQLTableStatisticsListPage) Values() []USQLTableStatistics {
2479 if page.utsl.IsEmpty() {
2480 return nil
2481 }
2482 return *page.utsl.Value
2483 }
2484
2485
2486 func NewUSQLTableStatisticsListPage(cur USQLTableStatisticsList, getNextPage func(context.Context, USQLTableStatisticsList) (USQLTableStatisticsList, error)) USQLTableStatisticsListPage {
2487 return USQLTableStatisticsListPage{
2488 fn: getNextPage,
2489 utsl: cur,
2490 }
2491 }
2492
2493
2494 type USQLTableType struct {
2495 autorest.Response `json:"-"`
2496
2497 Columns *[]TypeFieldInfo `json:"columns,omitempty"`
2498
2499 DatabaseName *string `json:"databaseName,omitempty"`
2500
2501 SchemaName *string `json:"schemaName,omitempty"`
2502
2503 Name *string `json:"typeName,omitempty"`
2504
2505 TypeFamily *string `json:"typeFamily,omitempty"`
2506
2507 CSharpName *string `json:"cSharpName,omitempty"`
2508
2509 FullCSharpName *string `json:"fullCSharpName,omitempty"`
2510
2511 SystemTypeID *int32 `json:"systemTypeId,omitempty"`
2512
2513 UserTypeID *int32 `json:"userTypeId,omitempty"`
2514
2515 SchemaID *int32 `json:"schemaId,omitempty"`
2516
2517 PrincipalID *int32 `json:"principalId,omitempty"`
2518
2519 IsNullable *bool `json:"isNullable,omitempty"`
2520
2521 IsUserDefined *bool `json:"isUserDefined,omitempty"`
2522
2523 IsAssemblyType *bool `json:"isAssemblyType,omitempty"`
2524
2525 IsTableType *bool `json:"isTableType,omitempty"`
2526
2527 IsComplexType *bool `json:"isComplexType,omitempty"`
2528
2529 ComputeAccountName *string `json:"computeAccountName,omitempty"`
2530
2531 Version *uuid.UUID `json:"version,omitempty"`
2532 }
2533
2534
2535 func (ustt USQLTableType) MarshalJSON() ([]byte, error) {
2536 objectMap := make(map[string]interface{})
2537 if ustt.DatabaseName != nil {
2538 objectMap["databaseName"] = ustt.DatabaseName
2539 }
2540 if ustt.SchemaName != nil {
2541 objectMap["schemaName"] = ustt.SchemaName
2542 }
2543 if ustt.Name != nil {
2544 objectMap["typeName"] = ustt.Name
2545 }
2546 if ustt.TypeFamily != nil {
2547 objectMap["typeFamily"] = ustt.TypeFamily
2548 }
2549 if ustt.CSharpName != nil {
2550 objectMap["cSharpName"] = ustt.CSharpName
2551 }
2552 if ustt.FullCSharpName != nil {
2553 objectMap["fullCSharpName"] = ustt.FullCSharpName
2554 }
2555 if ustt.SystemTypeID != nil {
2556 objectMap["systemTypeId"] = ustt.SystemTypeID
2557 }
2558 if ustt.UserTypeID != nil {
2559 objectMap["userTypeId"] = ustt.UserTypeID
2560 }
2561 if ustt.SchemaID != nil {
2562 objectMap["schemaId"] = ustt.SchemaID
2563 }
2564 if ustt.PrincipalID != nil {
2565 objectMap["principalId"] = ustt.PrincipalID
2566 }
2567 if ustt.IsNullable != nil {
2568 objectMap["isNullable"] = ustt.IsNullable
2569 }
2570 if ustt.IsUserDefined != nil {
2571 objectMap["isUserDefined"] = ustt.IsUserDefined
2572 }
2573 if ustt.IsAssemblyType != nil {
2574 objectMap["isAssemblyType"] = ustt.IsAssemblyType
2575 }
2576 if ustt.IsTableType != nil {
2577 objectMap["isTableType"] = ustt.IsTableType
2578 }
2579 if ustt.IsComplexType != nil {
2580 objectMap["isComplexType"] = ustt.IsComplexType
2581 }
2582 if ustt.ComputeAccountName != nil {
2583 objectMap["computeAccountName"] = ustt.ComputeAccountName
2584 }
2585 if ustt.Version != nil {
2586 objectMap["version"] = ustt.Version
2587 }
2588 return json.Marshal(objectMap)
2589 }
2590
2591
2592 type USQLTableTypeList struct {
2593 autorest.Response `json:"-"`
2594
2595 Value *[]USQLTableType `json:"value,omitempty"`
2596
2597 NextLink *string `json:"nextLink,omitempty"`
2598 }
2599
2600
2601 func (usttl USQLTableTypeList) MarshalJSON() ([]byte, error) {
2602 objectMap := make(map[string]interface{})
2603 if usttl.NextLink != nil {
2604 objectMap["nextLink"] = usttl.NextLink
2605 }
2606 return json.Marshal(objectMap)
2607 }
2608
2609
2610 type USQLTableTypeListIterator struct {
2611 i int
2612 page USQLTableTypeListPage
2613 }
2614
2615
2616
2617 func (iter *USQLTableTypeListIterator) NextWithContext(ctx context.Context) (err error) {
2618 if tracing.IsEnabled() {
2619 ctx = tracing.StartSpan(ctx, fqdn+"/USQLTableTypeListIterator.NextWithContext")
2620 defer func() {
2621 sc := -1
2622 if iter.Response().Response.Response != nil {
2623 sc = iter.Response().Response.Response.StatusCode
2624 }
2625 tracing.EndSpan(ctx, sc, err)
2626 }()
2627 }
2628 iter.i++
2629 if iter.i < len(iter.page.Values()) {
2630 return nil
2631 }
2632 err = iter.page.NextWithContext(ctx)
2633 if err != nil {
2634 iter.i--
2635 return err
2636 }
2637 iter.i = 0
2638 return nil
2639 }
2640
2641
2642
2643
2644 func (iter *USQLTableTypeListIterator) Next() error {
2645 return iter.NextWithContext(context.Background())
2646 }
2647
2648
2649 func (iter USQLTableTypeListIterator) NotDone() bool {
2650 return iter.page.NotDone() && iter.i < len(iter.page.Values())
2651 }
2652
2653
2654 func (iter USQLTableTypeListIterator) Response() USQLTableTypeList {
2655 return iter.page.Response()
2656 }
2657
2658
2659
2660 func (iter USQLTableTypeListIterator) Value() USQLTableType {
2661 if !iter.page.NotDone() {
2662 return USQLTableType{}
2663 }
2664 return iter.page.Values()[iter.i]
2665 }
2666
2667
2668 func NewUSQLTableTypeListIterator(page USQLTableTypeListPage) USQLTableTypeListIterator {
2669 return USQLTableTypeListIterator{page: page}
2670 }
2671
2672
2673 func (usttl USQLTableTypeList) IsEmpty() bool {
2674 return usttl.Value == nil || len(*usttl.Value) == 0
2675 }
2676
2677
2678 func (usttl USQLTableTypeList) hasNextLink() bool {
2679 return usttl.NextLink != nil && len(*usttl.NextLink) != 0
2680 }
2681
2682
2683
2684 func (usttl USQLTableTypeList) uSQLTableTypeListPreparer(ctx context.Context) (*http.Request, error) {
2685 if !usttl.hasNextLink() {
2686 return nil, nil
2687 }
2688 return autorest.Prepare((&http.Request{}).WithContext(ctx),
2689 autorest.AsJSON(),
2690 autorest.AsGet(),
2691 autorest.WithBaseURL(to.String(usttl.NextLink)))
2692 }
2693
2694
2695 type USQLTableTypeListPage struct {
2696 fn func(context.Context, USQLTableTypeList) (USQLTableTypeList, error)
2697 uttl USQLTableTypeList
2698 }
2699
2700
2701
2702 func (page *USQLTableTypeListPage) NextWithContext(ctx context.Context) (err error) {
2703 if tracing.IsEnabled() {
2704 ctx = tracing.StartSpan(ctx, fqdn+"/USQLTableTypeListPage.NextWithContext")
2705 defer func() {
2706 sc := -1
2707 if page.Response().Response.Response != nil {
2708 sc = page.Response().Response.Response.StatusCode
2709 }
2710 tracing.EndSpan(ctx, sc, err)
2711 }()
2712 }
2713 for {
2714 next, err := page.fn(ctx, page.uttl)
2715 if err != nil {
2716 return err
2717 }
2718 page.uttl = next
2719 if !next.hasNextLink() || !next.IsEmpty() {
2720 break
2721 }
2722 }
2723 return nil
2724 }
2725
2726
2727
2728
2729 func (page *USQLTableTypeListPage) Next() error {
2730 return page.NextWithContext(context.Background())
2731 }
2732
2733
2734 func (page USQLTableTypeListPage) NotDone() bool {
2735 return !page.uttl.IsEmpty()
2736 }
2737
2738
2739 func (page USQLTableTypeListPage) Response() USQLTableTypeList {
2740 return page.uttl
2741 }
2742
2743
2744 func (page USQLTableTypeListPage) Values() []USQLTableType {
2745 if page.uttl.IsEmpty() {
2746 return nil
2747 }
2748 return *page.uttl.Value
2749 }
2750
2751
2752 func NewUSQLTableTypeListPage(cur USQLTableTypeList, getNextPage func(context.Context, USQLTableTypeList) (USQLTableTypeList, error)) USQLTableTypeListPage {
2753 return USQLTableTypeListPage{
2754 fn: getNextPage,
2755 uttl: cur,
2756 }
2757 }
2758
2759
2760 type USQLTableValuedFunction struct {
2761 autorest.Response `json:"-"`
2762
2763 DatabaseName *string `json:"databaseName,omitempty"`
2764
2765 SchemaName *string `json:"schemaName,omitempty"`
2766
2767 Name *string `json:"tvfName,omitempty"`
2768
2769 Definition *string `json:"definition,omitempty"`
2770
2771 ComputeAccountName *string `json:"computeAccountName,omitempty"`
2772
2773 Version *uuid.UUID `json:"version,omitempty"`
2774 }
2775
2776
2777 type USQLTableValuedFunctionList struct {
2778 autorest.Response `json:"-"`
2779
2780 Value *[]USQLTableValuedFunction `json:"value,omitempty"`
2781
2782 NextLink *string `json:"nextLink,omitempty"`
2783 }
2784
2785
2786 func (ustvfl USQLTableValuedFunctionList) MarshalJSON() ([]byte, error) {
2787 objectMap := make(map[string]interface{})
2788 if ustvfl.NextLink != nil {
2789 objectMap["nextLink"] = ustvfl.NextLink
2790 }
2791 return json.Marshal(objectMap)
2792 }
2793
2794
2795
2796 type USQLTableValuedFunctionListIterator struct {
2797 i int
2798 page USQLTableValuedFunctionListPage
2799 }
2800
2801
2802
2803 func (iter *USQLTableValuedFunctionListIterator) NextWithContext(ctx context.Context) (err error) {
2804 if tracing.IsEnabled() {
2805 ctx = tracing.StartSpan(ctx, fqdn+"/USQLTableValuedFunctionListIterator.NextWithContext")
2806 defer func() {
2807 sc := -1
2808 if iter.Response().Response.Response != nil {
2809 sc = iter.Response().Response.Response.StatusCode
2810 }
2811 tracing.EndSpan(ctx, sc, err)
2812 }()
2813 }
2814 iter.i++
2815 if iter.i < len(iter.page.Values()) {
2816 return nil
2817 }
2818 err = iter.page.NextWithContext(ctx)
2819 if err != nil {
2820 iter.i--
2821 return err
2822 }
2823 iter.i = 0
2824 return nil
2825 }
2826
2827
2828
2829
2830 func (iter *USQLTableValuedFunctionListIterator) Next() error {
2831 return iter.NextWithContext(context.Background())
2832 }
2833
2834
2835 func (iter USQLTableValuedFunctionListIterator) NotDone() bool {
2836 return iter.page.NotDone() && iter.i < len(iter.page.Values())
2837 }
2838
2839
2840 func (iter USQLTableValuedFunctionListIterator) Response() USQLTableValuedFunctionList {
2841 return iter.page.Response()
2842 }
2843
2844
2845
2846 func (iter USQLTableValuedFunctionListIterator) Value() USQLTableValuedFunction {
2847 if !iter.page.NotDone() {
2848 return USQLTableValuedFunction{}
2849 }
2850 return iter.page.Values()[iter.i]
2851 }
2852
2853
2854 func NewUSQLTableValuedFunctionListIterator(page USQLTableValuedFunctionListPage) USQLTableValuedFunctionListIterator {
2855 return USQLTableValuedFunctionListIterator{page: page}
2856 }
2857
2858
2859 func (ustvfl USQLTableValuedFunctionList) IsEmpty() bool {
2860 return ustvfl.Value == nil || len(*ustvfl.Value) == 0
2861 }
2862
2863
2864 func (ustvfl USQLTableValuedFunctionList) hasNextLink() bool {
2865 return ustvfl.NextLink != nil && len(*ustvfl.NextLink) != 0
2866 }
2867
2868
2869
2870 func (ustvfl USQLTableValuedFunctionList) uSQLTableValuedFunctionListPreparer(ctx context.Context) (*http.Request, error) {
2871 if !ustvfl.hasNextLink() {
2872 return nil, nil
2873 }
2874 return autorest.Prepare((&http.Request{}).WithContext(ctx),
2875 autorest.AsJSON(),
2876 autorest.AsGet(),
2877 autorest.WithBaseURL(to.String(ustvfl.NextLink)))
2878 }
2879
2880
2881 type USQLTableValuedFunctionListPage struct {
2882 fn func(context.Context, USQLTableValuedFunctionList) (USQLTableValuedFunctionList, error)
2883 utvfl USQLTableValuedFunctionList
2884 }
2885
2886
2887
2888 func (page *USQLTableValuedFunctionListPage) NextWithContext(ctx context.Context) (err error) {
2889 if tracing.IsEnabled() {
2890 ctx = tracing.StartSpan(ctx, fqdn+"/USQLTableValuedFunctionListPage.NextWithContext")
2891 defer func() {
2892 sc := -1
2893 if page.Response().Response.Response != nil {
2894 sc = page.Response().Response.Response.StatusCode
2895 }
2896 tracing.EndSpan(ctx, sc, err)
2897 }()
2898 }
2899 for {
2900 next, err := page.fn(ctx, page.utvfl)
2901 if err != nil {
2902 return err
2903 }
2904 page.utvfl = next
2905 if !next.hasNextLink() || !next.IsEmpty() {
2906 break
2907 }
2908 }
2909 return nil
2910 }
2911
2912
2913
2914
2915 func (page *USQLTableValuedFunctionListPage) Next() error {
2916 return page.NextWithContext(context.Background())
2917 }
2918
2919
2920 func (page USQLTableValuedFunctionListPage) NotDone() bool {
2921 return !page.utvfl.IsEmpty()
2922 }
2923
2924
2925 func (page USQLTableValuedFunctionListPage) Response() USQLTableValuedFunctionList {
2926 return page.utvfl
2927 }
2928
2929
2930 func (page USQLTableValuedFunctionListPage) Values() []USQLTableValuedFunction {
2931 if page.utvfl.IsEmpty() {
2932 return nil
2933 }
2934 return *page.utvfl.Value
2935 }
2936
2937
2938 func NewUSQLTableValuedFunctionListPage(cur USQLTableValuedFunctionList, getNextPage func(context.Context, USQLTableValuedFunctionList) (USQLTableValuedFunctionList, error)) USQLTableValuedFunctionListPage {
2939 return USQLTableValuedFunctionListPage{
2940 fn: getNextPage,
2941 utvfl: cur,
2942 }
2943 }
2944
2945
2946 type USQLType struct {
2947
2948 DatabaseName *string `json:"databaseName,omitempty"`
2949
2950 SchemaName *string `json:"schemaName,omitempty"`
2951
2952 Name *string `json:"typeName,omitempty"`
2953
2954 TypeFamily *string `json:"typeFamily,omitempty"`
2955
2956 CSharpName *string `json:"cSharpName,omitempty"`
2957
2958 FullCSharpName *string `json:"fullCSharpName,omitempty"`
2959
2960 SystemTypeID *int32 `json:"systemTypeId,omitempty"`
2961
2962 UserTypeID *int32 `json:"userTypeId,omitempty"`
2963
2964 SchemaID *int32 `json:"schemaId,omitempty"`
2965
2966 PrincipalID *int32 `json:"principalId,omitempty"`
2967
2968 IsNullable *bool `json:"isNullable,omitempty"`
2969
2970 IsUserDefined *bool `json:"isUserDefined,omitempty"`
2971
2972 IsAssemblyType *bool `json:"isAssemblyType,omitempty"`
2973
2974 IsTableType *bool `json:"isTableType,omitempty"`
2975
2976 IsComplexType *bool `json:"isComplexType,omitempty"`
2977
2978 ComputeAccountName *string `json:"computeAccountName,omitempty"`
2979
2980 Version *uuid.UUID `json:"version,omitempty"`
2981 }
2982
2983
2984 type USQLTypeList struct {
2985 autorest.Response `json:"-"`
2986
2987 Value *[]USQLType `json:"value,omitempty"`
2988
2989 NextLink *string `json:"nextLink,omitempty"`
2990 }
2991
2992
2993 func (ustl USQLTypeList) MarshalJSON() ([]byte, error) {
2994 objectMap := make(map[string]interface{})
2995 if ustl.NextLink != nil {
2996 objectMap["nextLink"] = ustl.NextLink
2997 }
2998 return json.Marshal(objectMap)
2999 }
3000
3001
3002 type USQLTypeListIterator struct {
3003 i int
3004 page USQLTypeListPage
3005 }
3006
3007
3008
3009 func (iter *USQLTypeListIterator) NextWithContext(ctx context.Context) (err error) {
3010 if tracing.IsEnabled() {
3011 ctx = tracing.StartSpan(ctx, fqdn+"/USQLTypeListIterator.NextWithContext")
3012 defer func() {
3013 sc := -1
3014 if iter.Response().Response.Response != nil {
3015 sc = iter.Response().Response.Response.StatusCode
3016 }
3017 tracing.EndSpan(ctx, sc, err)
3018 }()
3019 }
3020 iter.i++
3021 if iter.i < len(iter.page.Values()) {
3022 return nil
3023 }
3024 err = iter.page.NextWithContext(ctx)
3025 if err != nil {
3026 iter.i--
3027 return err
3028 }
3029 iter.i = 0
3030 return nil
3031 }
3032
3033
3034
3035
3036 func (iter *USQLTypeListIterator) Next() error {
3037 return iter.NextWithContext(context.Background())
3038 }
3039
3040
3041 func (iter USQLTypeListIterator) NotDone() bool {
3042 return iter.page.NotDone() && iter.i < len(iter.page.Values())
3043 }
3044
3045
3046 func (iter USQLTypeListIterator) Response() USQLTypeList {
3047 return iter.page.Response()
3048 }
3049
3050
3051
3052 func (iter USQLTypeListIterator) Value() USQLType {
3053 if !iter.page.NotDone() {
3054 return USQLType{}
3055 }
3056 return iter.page.Values()[iter.i]
3057 }
3058
3059
3060 func NewUSQLTypeListIterator(page USQLTypeListPage) USQLTypeListIterator {
3061 return USQLTypeListIterator{page: page}
3062 }
3063
3064
3065 func (ustl USQLTypeList) IsEmpty() bool {
3066 return ustl.Value == nil || len(*ustl.Value) == 0
3067 }
3068
3069
3070 func (ustl USQLTypeList) hasNextLink() bool {
3071 return ustl.NextLink != nil && len(*ustl.NextLink) != 0
3072 }
3073
3074
3075
3076 func (ustl USQLTypeList) uSQLTypeListPreparer(ctx context.Context) (*http.Request, error) {
3077 if !ustl.hasNextLink() {
3078 return nil, nil
3079 }
3080 return autorest.Prepare((&http.Request{}).WithContext(ctx),
3081 autorest.AsJSON(),
3082 autorest.AsGet(),
3083 autorest.WithBaseURL(to.String(ustl.NextLink)))
3084 }
3085
3086
3087 type USQLTypeListPage struct {
3088 fn func(context.Context, USQLTypeList) (USQLTypeList, error)
3089 utl USQLTypeList
3090 }
3091
3092
3093
3094 func (page *USQLTypeListPage) NextWithContext(ctx context.Context) (err error) {
3095 if tracing.IsEnabled() {
3096 ctx = tracing.StartSpan(ctx, fqdn+"/USQLTypeListPage.NextWithContext")
3097 defer func() {
3098 sc := -1
3099 if page.Response().Response.Response != nil {
3100 sc = page.Response().Response.Response.StatusCode
3101 }
3102 tracing.EndSpan(ctx, sc, err)
3103 }()
3104 }
3105 for {
3106 next, err := page.fn(ctx, page.utl)
3107 if err != nil {
3108 return err
3109 }
3110 page.utl = next
3111 if !next.hasNextLink() || !next.IsEmpty() {
3112 break
3113 }
3114 }
3115 return nil
3116 }
3117
3118
3119
3120
3121 func (page *USQLTypeListPage) Next() error {
3122 return page.NextWithContext(context.Background())
3123 }
3124
3125
3126 func (page USQLTypeListPage) NotDone() bool {
3127 return !page.utl.IsEmpty()
3128 }
3129
3130
3131 func (page USQLTypeListPage) Response() USQLTypeList {
3132 return page.utl
3133 }
3134
3135
3136 func (page USQLTypeListPage) Values() []USQLType {
3137 if page.utl.IsEmpty() {
3138 return nil
3139 }
3140 return *page.utl.Value
3141 }
3142
3143
3144 func NewUSQLTypeListPage(cur USQLTypeList, getNextPage func(context.Context, USQLTypeList) (USQLTypeList, error)) USQLTypeListPage {
3145 return USQLTypeListPage{
3146 fn: getNextPage,
3147 utl: cur,
3148 }
3149 }
3150
3151
3152 type USQLView struct {
3153 autorest.Response `json:"-"`
3154
3155 DatabaseName *string `json:"databaseName,omitempty"`
3156
3157 SchemaName *string `json:"schemaName,omitempty"`
3158
3159 Name *string `json:"viewName,omitempty"`
3160
3161 Definition *string `json:"definition,omitempty"`
3162
3163 ComputeAccountName *string `json:"computeAccountName,omitempty"`
3164
3165 Version *uuid.UUID `json:"version,omitempty"`
3166 }
3167
3168
3169 type USQLViewList struct {
3170 autorest.Response `json:"-"`
3171
3172 Value *[]USQLView `json:"value,omitempty"`
3173
3174 NextLink *string `json:"nextLink,omitempty"`
3175 }
3176
3177
3178 func (usvl USQLViewList) MarshalJSON() ([]byte, error) {
3179 objectMap := make(map[string]interface{})
3180 if usvl.NextLink != nil {
3181 objectMap["nextLink"] = usvl.NextLink
3182 }
3183 return json.Marshal(objectMap)
3184 }
3185
3186
3187 type USQLViewListIterator struct {
3188 i int
3189 page USQLViewListPage
3190 }
3191
3192
3193
3194 func (iter *USQLViewListIterator) NextWithContext(ctx context.Context) (err error) {
3195 if tracing.IsEnabled() {
3196 ctx = tracing.StartSpan(ctx, fqdn+"/USQLViewListIterator.NextWithContext")
3197 defer func() {
3198 sc := -1
3199 if iter.Response().Response.Response != nil {
3200 sc = iter.Response().Response.Response.StatusCode
3201 }
3202 tracing.EndSpan(ctx, sc, err)
3203 }()
3204 }
3205 iter.i++
3206 if iter.i < len(iter.page.Values()) {
3207 return nil
3208 }
3209 err = iter.page.NextWithContext(ctx)
3210 if err != nil {
3211 iter.i--
3212 return err
3213 }
3214 iter.i = 0
3215 return nil
3216 }
3217
3218
3219
3220
3221 func (iter *USQLViewListIterator) Next() error {
3222 return iter.NextWithContext(context.Background())
3223 }
3224
3225
3226 func (iter USQLViewListIterator) NotDone() bool {
3227 return iter.page.NotDone() && iter.i < len(iter.page.Values())
3228 }
3229
3230
3231 func (iter USQLViewListIterator) Response() USQLViewList {
3232 return iter.page.Response()
3233 }
3234
3235
3236
3237 func (iter USQLViewListIterator) Value() USQLView {
3238 if !iter.page.NotDone() {
3239 return USQLView{}
3240 }
3241 return iter.page.Values()[iter.i]
3242 }
3243
3244
3245 func NewUSQLViewListIterator(page USQLViewListPage) USQLViewListIterator {
3246 return USQLViewListIterator{page: page}
3247 }
3248
3249
3250 func (usvl USQLViewList) IsEmpty() bool {
3251 return usvl.Value == nil || len(*usvl.Value) == 0
3252 }
3253
3254
3255 func (usvl USQLViewList) hasNextLink() bool {
3256 return usvl.NextLink != nil && len(*usvl.NextLink) != 0
3257 }
3258
3259
3260
3261 func (usvl USQLViewList) uSQLViewListPreparer(ctx context.Context) (*http.Request, error) {
3262 if !usvl.hasNextLink() {
3263 return nil, nil
3264 }
3265 return autorest.Prepare((&http.Request{}).WithContext(ctx),
3266 autorest.AsJSON(),
3267 autorest.AsGet(),
3268 autorest.WithBaseURL(to.String(usvl.NextLink)))
3269 }
3270
3271
3272 type USQLViewListPage struct {
3273 fn func(context.Context, USQLViewList) (USQLViewList, error)
3274 uvl USQLViewList
3275 }
3276
3277
3278
3279 func (page *USQLViewListPage) NextWithContext(ctx context.Context) (err error) {
3280 if tracing.IsEnabled() {
3281 ctx = tracing.StartSpan(ctx, fqdn+"/USQLViewListPage.NextWithContext")
3282 defer func() {
3283 sc := -1
3284 if page.Response().Response.Response != nil {
3285 sc = page.Response().Response.Response.StatusCode
3286 }
3287 tracing.EndSpan(ctx, sc, err)
3288 }()
3289 }
3290 for {
3291 next, err := page.fn(ctx, page.uvl)
3292 if err != nil {
3293 return err
3294 }
3295 page.uvl = next
3296 if !next.hasNextLink() || !next.IsEmpty() {
3297 break
3298 }
3299 }
3300 return nil
3301 }
3302
3303
3304
3305
3306 func (page *USQLViewListPage) Next() error {
3307 return page.NextWithContext(context.Background())
3308 }
3309
3310
3311 func (page USQLViewListPage) NotDone() bool {
3312 return !page.uvl.IsEmpty()
3313 }
3314
3315
3316 func (page USQLViewListPage) Response() USQLViewList {
3317 return page.uvl
3318 }
3319
3320
3321 func (page USQLViewListPage) Values() []USQLView {
3322 if page.uvl.IsEmpty() {
3323 return nil
3324 }
3325 return *page.uvl.Value
3326 }
3327
3328
3329 func NewUSQLViewListPage(cur USQLViewList, getNextPage func(context.Context, USQLViewList) (USQLViewList, error)) USQLViewListPage {
3330 return USQLViewListPage{
3331 fn: getNextPage,
3332 uvl: cur,
3333 }
3334 }
3335
View as plain text