Class: OCI::Opsi::Models::SqlStats

Inherits:
Object
  • Object
show all
Defined in:
lib/oci/opsi/models/sql_stats.rb

Overview

Sql Stats type object.

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(attributes = {}) ⇒ SqlStats

Initializes the object

Parameters:

  • attributes (Hash) (defaults to: {}) —

    Model attributes in the form of hash

Options Hash (attributes):

  • :sql_identifier (String) —

    The value to assign to the #sql_identifier property

  • :plan_hash_value (Integer) —

    The value to assign to the #plan_hash_value property

  • :time_collected (DateTime) —

    The value to assign to the #time_collected property

  • :instance_name (String) —

    The value to assign to the #instance_name property

  • :last_active_time (String) —

    The value to assign to the #last_active_time property

  • :parse_calls (Integer) —

    The value to assign to the #parse_calls property

  • :disk_reads (Integer) —

    The value to assign to the #disk_reads property

  • :direct_reads (Integer) —

    The value to assign to the #direct_reads property

  • :direct_writes (Integer) —

    The value to assign to the #direct_writes property

  • :buffer_gets (Integer) —

    The value to assign to the #buffer_gets property

  • :rows_processed (Integer) —

    The value to assign to the #rows_processed property

  • :serializable_aborts (Integer) —

    The value to assign to the #serializable_aborts property

  • :fetches (Integer) —

    The value to assign to the #fetches property

  • :executions (Integer) —

    The value to assign to the #executions property

  • :avoided_executions (Integer) —

    The value to assign to the #avoided_executions property

  • :end_of_fetch_count (Integer) —

    The value to assign to the #end_of_fetch_count property

  • :loads (Integer) —

    The value to assign to the #loads property

  • :version_count (Integer) —

    The value to assign to the #version_count property

  • :invalidations (Integer) —

    The value to assign to the #invalidations property

  • :obsolete_count (Integer) —

    The value to assign to the #obsolete_count property

  • :px_servers_executions (Integer) —

    The value to assign to the #px_servers_executions property

  • :cpu_time_in_us (Integer) —

    The value to assign to the #cpu_time_in_us property

  • :elapsed_time_in_us (Integer) —

    The value to assign to the #elapsed_time_in_us property

  • :avg_hard_parse_time_in_us (Integer) —

    The value to assign to the #avg_hard_parse_time_in_us property

  • :concurrency_wait_time_in_us (Integer) —

    The value to assign to the #concurrency_wait_time_in_us property

  • :application_wait_time_in_us (Integer) —

    The value to assign to the #application_wait_time_in_us property

  • :cluster_wait_time_in_us (Integer) —

    The value to assign to the #cluster_wait_time_in_us property

  • :user_io_wait_time_in_us (Integer) —

    The value to assign to the #user_io_wait_time_in_us property

  • :plsql_exec_time_in_us (Integer) —

    The value to assign to the #plsql_exec_time_in_us property

  • :java_exec_time_in_us (Integer) —

    The value to assign to the #java_exec_time_in_us property

  • :sorts (Integer) —

    The value to assign to the #sorts property

  • :sharable_mem (Integer) —

    The value to assign to the #sharable_mem property

  • :total_sharable_mem (Integer) —

    The value to assign to the #total_sharable_mem property

  • :type_check_mem (Integer) —

    The value to assign to the #type_check_mem property

  • :io_cell_offload_eligible_bytes (Integer) —

    The value to assign to the #io_cell_offload_eligible_bytes property

  • :io_interconnect_bytes (Integer) —

    The value to assign to the #io_interconnect_bytes property

  • :physical_read_requests (Integer) —

    The value to assign to the #physical_read_requests property

  • :physical_read_bytes (Integer) —

    The value to assign to the #physical_read_bytes property

  • :physical_write_requests (Integer) —

    The value to assign to the #physical_write_requests property

  • :physical_write_bytes (Integer) —

    The value to assign to the #physical_write_bytes property

  • :exact_matching_signature (String) —

    The value to assign to the #exact_matching_signature property

  • :force_matching_signature (String) —

    The value to assign to the #force_matching_signature property

  • :io_cell_uncompressed_bytes (Integer) —

    The value to assign to the #io_cell_uncompressed_bytes property

  • :io_cell_offload_returned_bytes (Integer) —

    The value to assign to the #io_cell_offload_returned_bytes property

  • :child_number (Integer) —

    The value to assign to the #child_number property

  • :command_type (Integer) —

    The value to assign to the #command_type property

  • :users_opening (Integer) —

    The value to assign to the #users_opening property

  • :users_executing (Integer) —

    The value to assign to the #users_executing property

  • :optimizer_cost (Integer) —

    The value to assign to the #optimizer_cost property

  • :full_plan_hash_value (String) —

    The value to assign to the #full_plan_hash_value property

  • :_module (String) —

    The value to assign to the #_module property

  • :service (String) —

    The value to assign to the #service property

  • :action (String) —

    The value to assign to the #action property

  • :sql_profile (String) —

    The value to assign to the #sql_profile property

  • :sql_patch (String) —

    The value to assign to the #sql_patch property

  • :sql_plan_baseline (String) —

    The value to assign to the #sql_plan_baseline property

  • :delta_execution_count (Integer) —

    The value to assign to the #delta_execution_count property

  • :delta_cpu_time (Integer) —

    The value to assign to the #delta_cpu_time property

  • :delta_io_bytes (Integer) —

    The value to assign to the #delta_io_bytes property

  • :delta_cpu_rank (Integer) —

    The value to assign to the #delta_cpu_rank property

  • :delta_execs_rank (Integer) —

    The value to assign to the #delta_execs_rank property

  • :sharable_mem_rank (Integer) —

    The value to assign to the #sharable_mem_rank property

  • :delta_io_rank (Integer) —

    The value to assign to the #delta_io_rank property

  • :harmonic_sum (Integer) —

    The value to assign to the #harmonic_sum property

  • :wt_harmonic_sum (Integer) —

    The value to assign to the #wt_harmonic_sum property

  • :total_sql_count (Integer) —

    The value to assign to the #total_sql_count property



507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 507

def initialize(attributes = {})
  return unless attributes.is_a?(Hash)

  # convert string to symbol for hash key
  attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }

  self.sql_identifier = attributes[:'sqlIdentifier'] if attributes[:'sqlIdentifier']

  raise 'You cannot provide both :sqlIdentifier and :sql_identifier' if attributes.key?(:'sqlIdentifier') && attributes.key?(:'sql_identifier')

  self.sql_identifier = attributes[:'sql_identifier'] if attributes[:'sql_identifier']

  self.plan_hash_value = attributes[:'planHashValue'] if attributes[:'planHashValue']

  raise 'You cannot provide both :planHashValue and :plan_hash_value' if attributes.key?(:'planHashValue') && attributes.key?(:'plan_hash_value')

  self.plan_hash_value = attributes[:'plan_hash_value'] if attributes[:'plan_hash_value']

  self.time_collected = attributes[:'timeCollected'] if attributes[:'timeCollected']

  raise 'You cannot provide both :timeCollected and :time_collected' if attributes.key?(:'timeCollected') && attributes.key?(:'time_collected')

  self.time_collected = attributes[:'time_collected'] if attributes[:'time_collected']

  self.instance_name = attributes[:'instanceName'] if attributes[:'instanceName']

  raise 'You cannot provide both :instanceName and :instance_name' if attributes.key?(:'instanceName') && attributes.key?(:'instance_name')

  self.instance_name = attributes[:'instance_name'] if attributes[:'instance_name']

  self.last_active_time = attributes[:'lastActiveTime'] if attributes[:'lastActiveTime']

  raise 'You cannot provide both :lastActiveTime and :last_active_time' if attributes.key?(:'lastActiveTime') && attributes.key?(:'last_active_time')

  self.last_active_time = attributes[:'last_active_time'] if attributes[:'last_active_time']

  self.parse_calls = attributes[:'parseCalls'] if attributes[:'parseCalls']

  raise 'You cannot provide both :parseCalls and :parse_calls' if attributes.key?(:'parseCalls') && attributes.key?(:'parse_calls')

  self.parse_calls = attributes[:'parse_calls'] if attributes[:'parse_calls']

  self.disk_reads = attributes[:'diskReads'] if attributes[:'diskReads']

  raise 'You cannot provide both :diskReads and :disk_reads' if attributes.key?(:'diskReads') && attributes.key?(:'disk_reads')

  self.disk_reads = attributes[:'disk_reads'] if attributes[:'disk_reads']

  self.direct_reads = attributes[:'directReads'] if attributes[:'directReads']

  raise 'You cannot provide both :directReads and :direct_reads' if attributes.key?(:'directReads') && attributes.key?(:'direct_reads')

  self.direct_reads = attributes[:'direct_reads'] if attributes[:'direct_reads']

  self.direct_writes = attributes[:'directWrites'] if attributes[:'directWrites']

  raise 'You cannot provide both :directWrites and :direct_writes' if attributes.key?(:'directWrites') && attributes.key?(:'direct_writes')

  self.direct_writes = attributes[:'direct_writes'] if attributes[:'direct_writes']

  self.buffer_gets = attributes[:'bufferGets'] if attributes[:'bufferGets']

  raise 'You cannot provide both :bufferGets and :buffer_gets' if attributes.key?(:'bufferGets') && attributes.key?(:'buffer_gets')

  self.buffer_gets = attributes[:'buffer_gets'] if attributes[:'buffer_gets']

  self.rows_processed = attributes[:'rowsProcessed'] if attributes[:'rowsProcessed']

  raise 'You cannot provide both :rowsProcessed and :rows_processed' if attributes.key?(:'rowsProcessed') && attributes.key?(:'rows_processed')

  self.rows_processed = attributes[:'rows_processed'] if attributes[:'rows_processed']

  self.serializable_aborts = attributes[:'serializableAborts'] if attributes[:'serializableAborts']

  raise 'You cannot provide both :serializableAborts and :serializable_aborts' if attributes.key?(:'serializableAborts') && attributes.key?(:'serializable_aborts')

  self.serializable_aborts = attributes[:'serializable_aborts'] if attributes[:'serializable_aborts']

  self.fetches = attributes[:'fetches'] if attributes[:'fetches']

  self.executions = attributes[:'executions'] if attributes[:'executions']

  self.avoided_executions = attributes[:'avoidedExecutions'] if attributes[:'avoidedExecutions']

  raise 'You cannot provide both :avoidedExecutions and :avoided_executions' if attributes.key?(:'avoidedExecutions') && attributes.key?(:'avoided_executions')

  self.avoided_executions = attributes[:'avoided_executions'] if attributes[:'avoided_executions']

  self.end_of_fetch_count = attributes[:'endOfFetchCount'] if attributes[:'endOfFetchCount']

  raise 'You cannot provide both :endOfFetchCount and :end_of_fetch_count' if attributes.key?(:'endOfFetchCount') && attributes.key?(:'end_of_fetch_count')

  self.end_of_fetch_count = attributes[:'end_of_fetch_count'] if attributes[:'end_of_fetch_count']

  self.loads = attributes[:'loads'] if attributes[:'loads']

  self.version_count = attributes[:'versionCount'] if attributes[:'versionCount']

  raise 'You cannot provide both :versionCount and :version_count' if attributes.key?(:'versionCount') && attributes.key?(:'version_count')

  self.version_count = attributes[:'version_count'] if attributes[:'version_count']

  self.invalidations = attributes[:'invalidations'] if attributes[:'invalidations']

  self.obsolete_count = attributes[:'obsoleteCount'] if attributes[:'obsoleteCount']

  raise 'You cannot provide both :obsoleteCount and :obsolete_count' if attributes.key?(:'obsoleteCount') && attributes.key?(:'obsolete_count')

  self.obsolete_count = attributes[:'obsolete_count'] if attributes[:'obsolete_count']

  self.px_servers_executions = attributes[:'pxServersExecutions'] if attributes[:'pxServersExecutions']

  raise 'You cannot provide both :pxServersExecutions and :px_servers_executions' if attributes.key?(:'pxServersExecutions') && attributes.key?(:'px_servers_executions')

  self.px_servers_executions = attributes[:'px_servers_executions'] if attributes[:'px_servers_executions']

  self.cpu_time_in_us = attributes[:'cpuTimeInUs'] if attributes[:'cpuTimeInUs']

  raise 'You cannot provide both :cpuTimeInUs and :cpu_time_in_us' if attributes.key?(:'cpuTimeInUs') && attributes.key?(:'cpu_time_in_us')

  self.cpu_time_in_us = attributes[:'cpu_time_in_us'] if attributes[:'cpu_time_in_us']

  self.elapsed_time_in_us = attributes[:'elapsedTimeInUs'] if attributes[:'elapsedTimeInUs']

  raise 'You cannot provide both :elapsedTimeInUs and :elapsed_time_in_us' if attributes.key?(:'elapsedTimeInUs') && attributes.key?(:'elapsed_time_in_us')

  self.elapsed_time_in_us = attributes[:'elapsed_time_in_us'] if attributes[:'elapsed_time_in_us']

  self.avg_hard_parse_time_in_us = attributes[:'avgHardParseTimeInUs'] if attributes[:'avgHardParseTimeInUs']

  raise 'You cannot provide both :avgHardParseTimeInUs and :avg_hard_parse_time_in_us' if attributes.key?(:'avgHardParseTimeInUs') && attributes.key?(:'avg_hard_parse_time_in_us')

  self.avg_hard_parse_time_in_us = attributes[:'avg_hard_parse_time_in_us'] if attributes[:'avg_hard_parse_time_in_us']

  self.concurrency_wait_time_in_us = attributes[:'concurrencyWaitTimeInUs'] if attributes[:'concurrencyWaitTimeInUs']

  raise 'You cannot provide both :concurrencyWaitTimeInUs and :concurrency_wait_time_in_us' if attributes.key?(:'concurrencyWaitTimeInUs') && attributes.key?(:'concurrency_wait_time_in_us')

  self.concurrency_wait_time_in_us = attributes[:'concurrency_wait_time_in_us'] if attributes[:'concurrency_wait_time_in_us']

  self.application_wait_time_in_us = attributes[:'applicationWaitTimeInUs'] if attributes[:'applicationWaitTimeInUs']

  raise 'You cannot provide both :applicationWaitTimeInUs and :application_wait_time_in_us' if attributes.key?(:'applicationWaitTimeInUs') && attributes.key?(:'application_wait_time_in_us')

  self.application_wait_time_in_us = attributes[:'application_wait_time_in_us'] if attributes[:'application_wait_time_in_us']

  self.cluster_wait_time_in_us = attributes[:'clusterWaitTimeInUs'] if attributes[:'clusterWaitTimeInUs']

  raise 'You cannot provide both :clusterWaitTimeInUs and :cluster_wait_time_in_us' if attributes.key?(:'clusterWaitTimeInUs') && attributes.key?(:'cluster_wait_time_in_us')

  self.cluster_wait_time_in_us = attributes[:'cluster_wait_time_in_us'] if attributes[:'cluster_wait_time_in_us']

  self.user_io_wait_time_in_us = attributes[:'userIoWaitTimeInUs'] if attributes[:'userIoWaitTimeInUs']

  raise 'You cannot provide both :userIoWaitTimeInUs and :user_io_wait_time_in_us' if attributes.key?(:'userIoWaitTimeInUs') && attributes.key?(:'user_io_wait_time_in_us')

  self.user_io_wait_time_in_us = attributes[:'user_io_wait_time_in_us'] if attributes[:'user_io_wait_time_in_us']

  self.plsql_exec_time_in_us = attributes[:'plsqlExecTimeInUs'] if attributes[:'plsqlExecTimeInUs']

  raise 'You cannot provide both :plsqlExecTimeInUs and :plsql_exec_time_in_us' if attributes.key?(:'plsqlExecTimeInUs') && attributes.key?(:'plsql_exec_time_in_us')

  self.plsql_exec_time_in_us = attributes[:'plsql_exec_time_in_us'] if attributes[:'plsql_exec_time_in_us']

  self.java_exec_time_in_us = attributes[:'javaExecTimeInUs'] if attributes[:'javaExecTimeInUs']

  raise 'You cannot provide both :javaExecTimeInUs and :java_exec_time_in_us' if attributes.key?(:'javaExecTimeInUs') && attributes.key?(:'java_exec_time_in_us')

  self.java_exec_time_in_us = attributes[:'java_exec_time_in_us'] if attributes[:'java_exec_time_in_us']

  self.sorts = attributes[:'sorts'] if attributes[:'sorts']

  self.sharable_mem = attributes[:'sharableMem'] if attributes[:'sharableMem']

  raise 'You cannot provide both :sharableMem and :sharable_mem' if attributes.key?(:'sharableMem') && attributes.key?(:'sharable_mem')

  self.sharable_mem = attributes[:'sharable_mem'] if attributes[:'sharable_mem']

  self.total_sharable_mem = attributes[:'totalSharableMem'] if attributes[:'totalSharableMem']

  raise 'You cannot provide both :totalSharableMem and :total_sharable_mem' if attributes.key?(:'totalSharableMem') && attributes.key?(:'total_sharable_mem')

  self.total_sharable_mem = attributes[:'total_sharable_mem'] if attributes[:'total_sharable_mem']

  self.type_check_mem = attributes[:'typeCheckMem'] if attributes[:'typeCheckMem']

  raise 'You cannot provide both :typeCheckMem and :type_check_mem' if attributes.key?(:'typeCheckMem') && attributes.key?(:'type_check_mem')

  self.type_check_mem = attributes[:'type_check_mem'] if attributes[:'type_check_mem']

  self.io_cell_offload_eligible_bytes = attributes[:'ioCellOffloadEligibleBytes'] if attributes[:'ioCellOffloadEligibleBytes']

  raise 'You cannot provide both :ioCellOffloadEligibleBytes and :io_cell_offload_eligible_bytes' if attributes.key?(:'ioCellOffloadEligibleBytes') && attributes.key?(:'io_cell_offload_eligible_bytes')

  self.io_cell_offload_eligible_bytes = attributes[:'io_cell_offload_eligible_bytes'] if attributes[:'io_cell_offload_eligible_bytes']

  self.io_interconnect_bytes = attributes[:'ioInterconnectBytes'] if attributes[:'ioInterconnectBytes']

  raise 'You cannot provide both :ioInterconnectBytes and :io_interconnect_bytes' if attributes.key?(:'ioInterconnectBytes') && attributes.key?(:'io_interconnect_bytes')

  self.io_interconnect_bytes = attributes[:'io_interconnect_bytes'] if attributes[:'io_interconnect_bytes']

  self.physical_read_requests = attributes[:'physicalReadRequests'] if attributes[:'physicalReadRequests']

  raise 'You cannot provide both :physicalReadRequests and :physical_read_requests' if attributes.key?(:'physicalReadRequests') && attributes.key?(:'physical_read_requests')

  self.physical_read_requests = attributes[:'physical_read_requests'] if attributes[:'physical_read_requests']

  self.physical_read_bytes = attributes[:'physicalReadBytes'] if attributes[:'physicalReadBytes']

  raise 'You cannot provide both :physicalReadBytes and :physical_read_bytes' if attributes.key?(:'physicalReadBytes') && attributes.key?(:'physical_read_bytes')

  self.physical_read_bytes = attributes[:'physical_read_bytes'] if attributes[:'physical_read_bytes']

  self.physical_write_requests = attributes[:'physicalWriteRequests'] if attributes[:'physicalWriteRequests']

  raise 'You cannot provide both :physicalWriteRequests and :physical_write_requests' if attributes.key?(:'physicalWriteRequests') && attributes.key?(:'physical_write_requests')

  self.physical_write_requests = attributes[:'physical_write_requests'] if attributes[:'physical_write_requests']

  self.physical_write_bytes = attributes[:'physicalWriteBytes'] if attributes[:'physicalWriteBytes']

  raise 'You cannot provide both :physicalWriteBytes and :physical_write_bytes' if attributes.key?(:'physicalWriteBytes') && attributes.key?(:'physical_write_bytes')

  self.physical_write_bytes = attributes[:'physical_write_bytes'] if attributes[:'physical_write_bytes']

  self.exact_matching_signature = attributes[:'exactMatchingSignature'] if attributes[:'exactMatchingSignature']

  raise 'You cannot provide both :exactMatchingSignature and :exact_matching_signature' if attributes.key?(:'exactMatchingSignature') && attributes.key?(:'exact_matching_signature')

  self.exact_matching_signature = attributes[:'exact_matching_signature'] if attributes[:'exact_matching_signature']

  self.force_matching_signature = attributes[:'forceMatchingSignature'] if attributes[:'forceMatchingSignature']

  raise 'You cannot provide both :forceMatchingSignature and :force_matching_signature' if attributes.key?(:'forceMatchingSignature') && attributes.key?(:'force_matching_signature')

  self.force_matching_signature = attributes[:'force_matching_signature'] if attributes[:'force_matching_signature']

  self.io_cell_uncompressed_bytes = attributes[:'ioCellUncompressedBytes'] if attributes[:'ioCellUncompressedBytes']

  raise 'You cannot provide both :ioCellUncompressedBytes and :io_cell_uncompressed_bytes' if attributes.key?(:'ioCellUncompressedBytes') && attributes.key?(:'io_cell_uncompressed_bytes')

  self.io_cell_uncompressed_bytes = attributes[:'io_cell_uncompressed_bytes'] if attributes[:'io_cell_uncompressed_bytes']

  self.io_cell_offload_returned_bytes = attributes[:'ioCellOffloadReturnedBytes'] if attributes[:'ioCellOffloadReturnedBytes']

  raise 'You cannot provide both :ioCellOffloadReturnedBytes and :io_cell_offload_returned_bytes' if attributes.key?(:'ioCellOffloadReturnedBytes') && attributes.key?(:'io_cell_offload_returned_bytes')

  self.io_cell_offload_returned_bytes = attributes[:'io_cell_offload_returned_bytes'] if attributes[:'io_cell_offload_returned_bytes']

  self.child_number = attributes[:'childNumber'] if attributes[:'childNumber']

  raise 'You cannot provide both :childNumber and :child_number' if attributes.key?(:'childNumber') && attributes.key?(:'child_number')

  self.child_number = attributes[:'child_number'] if attributes[:'child_number']

  self.command_type = attributes[:'commandType'] if attributes[:'commandType']

  raise 'You cannot provide both :commandType and :command_type' if attributes.key?(:'commandType') && attributes.key?(:'command_type')

  self.command_type = attributes[:'command_type'] if attributes[:'command_type']

  self.users_opening = attributes[:'usersOpening'] if attributes[:'usersOpening']

  raise 'You cannot provide both :usersOpening and :users_opening' if attributes.key?(:'usersOpening') && attributes.key?(:'users_opening')

  self.users_opening = attributes[:'users_opening'] if attributes[:'users_opening']

  self.users_executing = attributes[:'usersExecuting'] if attributes[:'usersExecuting']

  raise 'You cannot provide both :usersExecuting and :users_executing' if attributes.key?(:'usersExecuting') && attributes.key?(:'users_executing')

  self.users_executing = attributes[:'users_executing'] if attributes[:'users_executing']

  self.optimizer_cost = attributes[:'optimizerCost'] if attributes[:'optimizerCost']

  raise 'You cannot provide both :optimizerCost and :optimizer_cost' if attributes.key?(:'optimizerCost') && attributes.key?(:'optimizer_cost')

  self.optimizer_cost = attributes[:'optimizer_cost'] if attributes[:'optimizer_cost']

  self.full_plan_hash_value = attributes[:'fullPlanHashValue'] if attributes[:'fullPlanHashValue']

  raise 'You cannot provide both :fullPlanHashValue and :full_plan_hash_value' if attributes.key?(:'fullPlanHashValue') && attributes.key?(:'full_plan_hash_value')

  self.full_plan_hash_value = attributes[:'full_plan_hash_value'] if attributes[:'full_plan_hash_value']

  self._module = attributes[:'module'] if attributes[:'module']

  raise 'You cannot provide both :module and :_module' if attributes.key?(:'module') && attributes.key?(:'_module')

  self._module = attributes[:'_module'] if attributes[:'_module']

  self.service = attributes[:'service'] if attributes[:'service']

  self.action = attributes[:'action'] if attributes[:'action']

  self.sql_profile = attributes[:'sqlProfile'] if attributes[:'sqlProfile']

  raise 'You cannot provide both :sqlProfile and :sql_profile' if attributes.key?(:'sqlProfile') && attributes.key?(:'sql_profile')

  self.sql_profile = attributes[:'sql_profile'] if attributes[:'sql_profile']

  self.sql_patch = attributes[:'sqlPatch'] if attributes[:'sqlPatch']

  raise 'You cannot provide both :sqlPatch and :sql_patch' if attributes.key?(:'sqlPatch') && attributes.key?(:'sql_patch')

  self.sql_patch = attributes[:'sql_patch'] if attributes[:'sql_patch']

  self.sql_plan_baseline = attributes[:'sqlPlanBaseline'] if attributes[:'sqlPlanBaseline']

  raise 'You cannot provide both :sqlPlanBaseline and :sql_plan_baseline' if attributes.key?(:'sqlPlanBaseline') && attributes.key?(:'sql_plan_baseline')

  self.sql_plan_baseline = attributes[:'sql_plan_baseline'] if attributes[:'sql_plan_baseline']

  self.delta_execution_count = attributes[:'deltaExecutionCount'] if attributes[:'deltaExecutionCount']

  raise 'You cannot provide both :deltaExecutionCount and :delta_execution_count' if attributes.key?(:'deltaExecutionCount') && attributes.key?(:'delta_execution_count')

  self.delta_execution_count = attributes[:'delta_execution_count'] if attributes[:'delta_execution_count']

  self.delta_cpu_time = attributes[:'deltaCpuTime'] if attributes[:'deltaCpuTime']

  raise 'You cannot provide both :deltaCpuTime and :delta_cpu_time' if attributes.key?(:'deltaCpuTime') && attributes.key?(:'delta_cpu_time')

  self.delta_cpu_time = attributes[:'delta_cpu_time'] if attributes[:'delta_cpu_time']

  self.delta_io_bytes = attributes[:'deltaIoBytes'] if attributes[:'deltaIoBytes']

  raise 'You cannot provide both :deltaIoBytes and :delta_io_bytes' if attributes.key?(:'deltaIoBytes') && attributes.key?(:'delta_io_bytes')

  self.delta_io_bytes = attributes[:'delta_io_bytes'] if attributes[:'delta_io_bytes']

  self.delta_cpu_rank = attributes[:'deltaCpuRank'] if attributes[:'deltaCpuRank']

  raise 'You cannot provide both :deltaCpuRank and :delta_cpu_rank' if attributes.key?(:'deltaCpuRank') && attributes.key?(:'delta_cpu_rank')

  self.delta_cpu_rank = attributes[:'delta_cpu_rank'] if attributes[:'delta_cpu_rank']

  self.delta_execs_rank = attributes[:'deltaExecsRank'] if attributes[:'deltaExecsRank']

  raise 'You cannot provide both :deltaExecsRank and :delta_execs_rank' if attributes.key?(:'deltaExecsRank') && attributes.key?(:'delta_execs_rank')

  self.delta_execs_rank = attributes[:'delta_execs_rank'] if attributes[:'delta_execs_rank']

  self.sharable_mem_rank = attributes[:'sharableMemRank'] if attributes[:'sharableMemRank']

  raise 'You cannot provide both :sharableMemRank and :sharable_mem_rank' if attributes.key?(:'sharableMemRank') && attributes.key?(:'sharable_mem_rank')

  self.sharable_mem_rank = attributes[:'sharable_mem_rank'] if attributes[:'sharable_mem_rank']

  self.delta_io_rank = attributes[:'deltaIoRank'] if attributes[:'deltaIoRank']

  raise 'You cannot provide both :deltaIoRank and :delta_io_rank' if attributes.key?(:'deltaIoRank') && attributes.key?(:'delta_io_rank')

  self.delta_io_rank = attributes[:'delta_io_rank'] if attributes[:'delta_io_rank']

  self.harmonic_sum = attributes[:'harmonicSum'] if attributes[:'harmonicSum']

  raise 'You cannot provide both :harmonicSum and :harmonic_sum' if attributes.key?(:'harmonicSum') && attributes.key?(:'harmonic_sum')

  self.harmonic_sum = attributes[:'harmonic_sum'] if attributes[:'harmonic_sum']

  self.wt_harmonic_sum = attributes[:'wtHarmonicSum'] if attributes[:'wtHarmonicSum']

  raise 'You cannot provide both :wtHarmonicSum and :wt_harmonic_sum' if attributes.key?(:'wtHarmonicSum') && attributes.key?(:'wt_harmonic_sum')

  self.wt_harmonic_sum = attributes[:'wt_harmonic_sum'] if attributes[:'wt_harmonic_sum']

  self.total_sql_count = attributes[:'totalSqlCount'] if attributes[:'totalSqlCount']

  raise 'You cannot provide both :totalSqlCount and :total_sql_count' if attributes.key?(:'totalSqlCount') && attributes.key?(:'total_sql_count')

  self.total_sql_count = attributes[:'total_sql_count'] if attributes[:'total_sql_count']
end

Instance Attribute Details

#_module ⇒ String

Module name

Returns:

  • (String) 


225
226
227
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 225

def _module
  @_module
end

#action ⇒ String

Contains the name of the action that was executing when the SQL statement was first parsed, which is set by calling DBMS_APPLICATION_INFO.SET_ACTION

Returns:

  • (String) 


233
234
235
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 233

def action
  @action
end

#application_wait_time_in_us ⇒ Integer

Application wait time (in microseconds)

Returns:

  • (Integer) 


121
122
123
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 121

def application_wait_time_in_us
  @application_wait_time_in_us
end

#avg_hard_parse_time_in_us ⇒ Integer

Average hard parse time (in microseconds) used by this cursor

Returns:

  • (Integer) 


113
114
115
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 113

def avg_hard_parse_time_in_us
  @avg_hard_parse_time_in_us
end

#avoided_executions ⇒ Integer

Number of executions attempted on this object, but prevented due to the SQL statement being in quarantine

Returns:

  • (Integer) 


77
78
79
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 77

def avoided_executions
  @avoided_executions
end

#buffer_gets ⇒ Integer

Number of Buffer Gets

Returns:

  • (Integer) 


57
58
59
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 57

def buffer_gets
  @buffer_gets
end

#child_number ⇒ Integer

Number of this child cursor

Returns:

  • (Integer) 


201
202
203
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 201

def child_number
  @child_number
end

#cluster_wait_time_in_us ⇒ Integer

Cluster wait time (in microseconds). This value is specific to Oracle RAC

Returns:

  • (Integer) 


125
126
127
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 125

def cluster_wait_time_in_us
  @cluster_wait_time_in_us
end

#command_type ⇒ Integer

Oracle command type definition

Returns:

  • (Integer) 


205
206
207
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 205

def command_type
  @command_type
end

#concurrency_wait_time_in_us ⇒ Integer

Concurrency wait time (in microseconds)

Returns:

  • (Integer) 


117
118
119
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 117

def concurrency_wait_time_in_us
  @concurrency_wait_time_in_us
end

#cpu_time_in_us ⇒ Integer

CPU time (in microseconds) used by this cursor for parsing, executing, and fetching

Returns:

  • (Integer) 


105
106
107
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 105

def cpu_time_in_us
  @cpu_time_in_us
end

#delta_cpu_rank ⇒ Integer

Rank based on CPU Consumption

Returns:

  • (Integer) 


261
262
263
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 261

def delta_cpu_rank
  @delta_cpu_rank
end

#delta_cpu_time ⇒ Integer

CPU time (in microseconds) for the cursor since the last AWR snapshot

Returns:

  • (Integer) 


253
254
255
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 253

def delta_cpu_time
  @delta_cpu_time
end

#delta_execs_rank ⇒ Integer

Rank based on number of execution

Returns:

  • (Integer) 


265
266
267
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 265

def delta_execs_rank
  @delta_execs_rank
end

#delta_execution_count ⇒ Integer

Number of executions for the cursor since the last AWR snapshot

Returns:

  • (Integer) 


249
250
251
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 249

def delta_execution_count
  @delta_execution_count
end

#delta_io_bytes ⇒ Integer

Number of I/O bytes exchanged between the Oracle database and the storage system for the cursor since the last AWR snapshot

Returns:

  • (Integer) 


257
258
259
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 257

def delta_io_bytes
  @delta_io_bytes
end

#delta_io_rank ⇒ Integer

Rank based on I/O Consumption

Returns:

  • (Integer) 


273
274
275
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 273

def delta_io_rank
  @delta_io_rank
end

#direct_reads ⇒ Integer

Number of direct reads

Returns:

  • (Integer) 


49
50
51
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 49

def direct_reads
  @direct_reads
end

#direct_writes ⇒ Integer

Number of Direct writes

Returns:

  • (Integer) 


53
54
55
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 53

def direct_writes
  @direct_writes
end

#disk_reads ⇒ Integer

Number of disk reads

Returns:

  • (Integer) 


45
46
47
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 45

def disk_reads
  @disk_reads
end

#elapsed_time_in_us ⇒ Integer

Elapsed time (in microseconds) used by this cursor for parsing, executing, and fetching.

Returns:

  • (Integer) 


109
110
111
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 109

def elapsed_time_in_us
  @elapsed_time_in_us
end

#end_of_fetch_count ⇒ Integer

Number of times this cursor was fully executed since the cursor was brought into the library cache

Returns:

  • (Integer) 


81
82
83
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 81

def end_of_fetch_count
  @end_of_fetch_count
end

#exact_matching_signature ⇒ String

exact_matching_signature Example: ‘"18067345456756876713"`

Returns:

  • (String) 


183
184
185
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 183

def exact_matching_signature
  @exact_matching_signature
end

#executions ⇒ Integer

Number of executions

Returns:

  • (Integer) 


73
74
75
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 73

def executions
  @executions
end

#fetches ⇒ Integer

Number of fetches

Returns:

  • (Integer) 


69
70
71
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 69

def fetches
  @fetches
end

#force_matching_signature ⇒ String

force_matching_signature Example: ‘"18067345456756876713"`

Returns:

  • (String) 


189
190
191
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 189

def force_matching_signature
  @force_matching_signature
end

#full_plan_hash_value ⇒ String

Total Number of rows in SQLStats table

Returns:

  • (String) 


221
222
223
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 221

def full_plan_hash_value
  @full_plan_hash_value
end

#harmonic_sum ⇒ Integer

Harmonic sum based on ranking parameters

Returns:

  • (Integer) 


277
278
279
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 277

def harmonic_sum
  @harmonic_sum
end

#instance_name ⇒ String

[Required] Name of Database Instance Example: ‘"DB10902_1"`

Returns:

  • (String) 


29
30
31
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 29

def instance_name
  @instance_name
end

#invalidations ⇒ Integer

Number of times this child cursor has been invalidated

Returns:

  • (Integer) 


93
94
95
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 93

def invalidations
  @invalidations
end

#io_cell_offload_eligible_bytes ⇒ Integer

Number of I/O bytes which can be filtered by the Exadata storage system

Returns:

  • (Integer) 


157
158
159
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 157

def io_cell_offload_eligible_bytes
  @io_cell_offload_eligible_bytes
end

#io_cell_offload_returned_bytes ⇒ Integer

Number of bytes that are returned by Exadata cell through the regular I/O path

Returns:

  • (Integer) 


197
198
199
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 197

def io_cell_offload_returned_bytes
  @io_cell_offload_returned_bytes
end

#io_cell_uncompressed_bytes ⇒ Integer

Number of uncompressed bytes (that is, size after decompression) that are offloaded to the Exadata cells

Returns:

  • (Integer) 


193
194
195
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 193

def io_cell_uncompressed_bytes
  @io_cell_uncompressed_bytes
end

#io_interconnect_bytes ⇒ Integer

Number of I/O bytes exchanged between Oracle Database and the storage system. Typically used for Cache Fusion or parallel queries

Returns:

  • (Integer) 


161
162
163
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 161

def io_interconnect_bytes
  @io_interconnect_bytes
end

#java_exec_time_in_us ⇒ Integer

Java execution time (in microseconds)

Returns:

  • (Integer) 


137
138
139
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 137

def java_exec_time_in_us
  @java_exec_time_in_us
end

#last_active_time ⇒ String

last_active_time Example: ‘"0000000099CCE300"`

Returns:

  • (String) 


35
36
37
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 35

def last_active_time
  @last_active_time
end

#loads ⇒ Integer

Number of times the object was either loaded or reloaded

Returns:

  • (Integer) 


85
86
87
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 85

def loads
  @loads
end

#obsolete_count ⇒ Integer

Number of times that a parent cursor became obsolete

Returns:

  • (Integer) 


97
98
99
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 97

def obsolete_count
  @obsolete_count
end

#optimizer_cost ⇒ Integer

Cost of this query given by the optimizer

Returns:

  • (Integer) 


217
218
219
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 217

def optimizer_cost
  @optimizer_cost
end

#parse_calls ⇒ Integer

Total integer of parse calls

Example: `60`

Returns:

  • (Integer) 


41
42
43
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 41

def parse_calls
  @parse_calls
end

#physical_read_bytes ⇒ Integer

Number of bytes read from disks by the monitored SQL

Returns:

  • (Integer) 


169
170
171
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 169

def physical_read_bytes
  @physical_read_bytes
end

#physical_read_requests ⇒ Integer

Number of physical read I/O requests issued by the monitored SQL. The requests may not be disk reads

Returns:

  • (Integer) 


165
166
167
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 165

def physical_read_requests
  @physical_read_requests
end

#physical_write_bytes ⇒ Integer

Number of bytes written to disks by the monitored SQL

Returns:

  • (Integer) 


177
178
179
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 177

def physical_write_bytes
  @physical_write_bytes
end

#physical_write_requests ⇒ Integer

Number of physical write I/O requests issued by the monitored SQL

Returns:

  • (Integer) 


173
174
175
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 173

def physical_write_requests
  @physical_write_requests
end

#plan_hash_value ⇒ Integer

[Required] Plan hash value for the SQL Execution Plan

Returns:

  • (Integer) 


17
18
19
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 17

def plan_hash_value
  @plan_hash_value
end

#plsql_exec_time_in_us ⇒ Integer

PL/SQL execution time (in microseconds)

Returns:

  • (Integer) 


133
134
135
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 133

def plsql_exec_time_in_us
  @plsql_exec_time_in_us
end

#px_servers_executions ⇒ Integer

Total number of executions performed by parallel execution servers (0 when the statement has never been executed in parallel)

Returns:

  • (Integer) 


101
102
103
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 101

def px_servers_executions
  @px_servers_executions
end

#rows_processed ⇒ Integer

Number of row processed

Returns:

  • (Integer) 


61
62
63
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 61

def rows_processed
  @rows_processed
end

#serializable_aborts ⇒ Integer

Number of serializable aborts

Returns:

  • (Integer) 


65
66
67
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 65

def serializable_aborts
  @serializable_aborts
end

#service ⇒ String

Service name

Returns:

  • (String) 


229
230
231
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 229

def service
  @service
end

#sharable_mem ⇒ Integer

Total shared memory (in bytes) currently occupied by all cursors with this SQL text and plan

Returns:

  • (Integer) 


145
146
147
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 145

def sharable_mem
  @sharable_mem
end

#sharable_mem_rank ⇒ Integer

Rank based on sharable memory

Returns:

  • (Integer) 


269
270
271
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 269

def sharable_mem_rank
  @sharable_mem_rank
end

#sorts ⇒ Integer

Number of sorts that were done for the child cursor

Returns:

  • (Integer) 


141
142
143
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 141

def sorts
  @sorts
end

#sql_identifier ⇒ String

[Required] Unique SQL_ID for a SQL Statement.

Returns:

  • (String) 


13
14
15
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 13

def sql_identifier
  @sql_identifier
end

#sql_patch ⇒ String

SQL patch used for this statement, if any

Returns:

  • (String) 


241
242
243
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 241

def sql_patch
  @sql_patch
end

#sql_plan_baseline ⇒ String

SQL plan baseline used for this statement, if any

Returns:

  • (String) 


245
246
247
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 245

def sql_plan_baseline
  @sql_plan_baseline
end

#sql_profile ⇒ String

SQL profile used for this statement, if any

Returns:

  • (String) 


237
238
239
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 237

def sql_profile
  @sql_profile
end

#time_collected ⇒ DateTime

[Required] Collection timestamp Example: ‘"2020-03-31T00:00:00.000Z"`

Returns:

  • (DateTime) 


23
24
25
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 23

def time_collected
  @time_collected
end

#total_sharable_mem ⇒ Integer

Total shared memory (in bytes) occupied by all cursors with this SQL text and plan if they were to be fully loaded in the shared pool (that is, cursor size)

Returns:

  • (Integer) 


149
150
151
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 149

def total_sharable_mem
  @total_sharable_mem
end

#total_sql_count ⇒ Integer

Total number of rows in SQLStats table

Returns:

  • (Integer) 


285
286
287
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 285

def total_sql_count
  @total_sql_count
end

#type_check_mem ⇒ Integer

Typecheck memory

Returns:

  • (Integer) 


153
154
155
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 153

def type_check_mem
  @type_check_mem
end

#user_io_wait_time_in_us ⇒ Integer

User I/O wait time (in microseconds)

Returns:

  • (Integer) 


129
130
131
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 129

def user_io_wait_time_in_us
  @user_io_wait_time_in_us
end

#users_executing ⇒ Integer

Number of users executing the statement

Returns:

  • (Integer) 


213
214
215
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 213

def users_executing
  @users_executing
end

#users_opening ⇒ Integer

Number of users that have any of the child cursors open

Returns:

  • (Integer) 


209
210
211
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 209

def users_opening
  @users_opening
end

#version_count ⇒ Integer

Number of cursors present in the cache with this SQL text and plan

Returns:

  • (Integer) 


89
90
91
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 89

def version_count
  @version_count
end

#wt_harmonic_sum ⇒ Integer

Weight based harmonic sum of ranking parameters

Returns:

  • (Integer) 


281
282
283
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 281

def wt_harmonic_sum
  @wt_harmonic_sum
end

Class Method Details

.attribute_map ⇒ Object

Attribute mapping from ruby-style variable name to JSON key.



288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 288

def self.attribute_map
  {
    # rubocop:disable Style/SymbolLiteral
    'sql_identifier': :'sqlIdentifier',
    'plan_hash_value': :'planHashValue',
    'time_collected': :'timeCollected',
    'instance_name': :'instanceName',
    'last_active_time': :'lastActiveTime',
    'parse_calls': :'parseCalls',
    'disk_reads': :'diskReads',
    'direct_reads': :'directReads',
    'direct_writes': :'directWrites',
    'buffer_gets': :'bufferGets',
    'rows_processed': :'rowsProcessed',
    'serializable_aborts': :'serializableAborts',
    'fetches': :'fetches',
    'executions': :'executions',
    'avoided_executions': :'avoidedExecutions',
    'end_of_fetch_count': :'endOfFetchCount',
    'loads': :'loads',
    'version_count': :'versionCount',
    'invalidations': :'invalidations',
    'obsolete_count': :'obsoleteCount',
    'px_servers_executions': :'pxServersExecutions',
    'cpu_time_in_us': :'cpuTimeInUs',
    'elapsed_time_in_us': :'elapsedTimeInUs',
    'avg_hard_parse_time_in_us': :'avgHardParseTimeInUs',
    'concurrency_wait_time_in_us': :'concurrencyWaitTimeInUs',
    'application_wait_time_in_us': :'applicationWaitTimeInUs',
    'cluster_wait_time_in_us': :'clusterWaitTimeInUs',
    'user_io_wait_time_in_us': :'userIoWaitTimeInUs',
    'plsql_exec_time_in_us': :'plsqlExecTimeInUs',
    'java_exec_time_in_us': :'javaExecTimeInUs',
    'sorts': :'sorts',
    'sharable_mem': :'sharableMem',
    'total_sharable_mem': :'totalSharableMem',
    'type_check_mem': :'typeCheckMem',
    'io_cell_offload_eligible_bytes': :'ioCellOffloadEligibleBytes',
    'io_interconnect_bytes': :'ioInterconnectBytes',
    'physical_read_requests': :'physicalReadRequests',
    'physical_read_bytes': :'physicalReadBytes',
    'physical_write_requests': :'physicalWriteRequests',
    'physical_write_bytes': :'physicalWriteBytes',
    'exact_matching_signature': :'exactMatchingSignature',
    'force_matching_signature': :'forceMatchingSignature',
    'io_cell_uncompressed_bytes': :'ioCellUncompressedBytes',
    'io_cell_offload_returned_bytes': :'ioCellOffloadReturnedBytes',
    'child_number': :'childNumber',
    'command_type': :'commandType',
    'users_opening': :'usersOpening',
    'users_executing': :'usersExecuting',
    'optimizer_cost': :'optimizerCost',
    'full_plan_hash_value': :'fullPlanHashValue',
    '_module': :'module',
    'service': :'service',
    'action': :'action',
    'sql_profile': :'sqlProfile',
    'sql_patch': :'sqlPatch',
    'sql_plan_baseline': :'sqlPlanBaseline',
    'delta_execution_count': :'deltaExecutionCount',
    'delta_cpu_time': :'deltaCpuTime',
    'delta_io_bytes': :'deltaIoBytes',
    'delta_cpu_rank': :'deltaCpuRank',
    'delta_execs_rank': :'deltaExecsRank',
    'sharable_mem_rank': :'sharableMemRank',
    'delta_io_rank': :'deltaIoRank',
    'harmonic_sum': :'harmonicSum',
    'wt_harmonic_sum': :'wtHarmonicSum',
    'total_sql_count': :'totalSqlCount'
    # rubocop:enable Style/SymbolLiteral
  }
end

.swagger_types ⇒ Object

Attribute type mapping.



362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 362

def self.swagger_types
  {
    # rubocop:disable Style/SymbolLiteral
    'sql_identifier': :'String',
    'plan_hash_value': :'Integer',
    'time_collected': :'DateTime',
    'instance_name': :'String',
    'last_active_time': :'String',
    'parse_calls': :'Integer',
    'disk_reads': :'Integer',
    'direct_reads': :'Integer',
    'direct_writes': :'Integer',
    'buffer_gets': :'Integer',
    'rows_processed': :'Integer',
    'serializable_aborts': :'Integer',
    'fetches': :'Integer',
    'executions': :'Integer',
    'avoided_executions': :'Integer',
    'end_of_fetch_count': :'Integer',
    'loads': :'Integer',
    'version_count': :'Integer',
    'invalidations': :'Integer',
    'obsolete_count': :'Integer',
    'px_servers_executions': :'Integer',
    'cpu_time_in_us': :'Integer',
    'elapsed_time_in_us': :'Integer',
    'avg_hard_parse_time_in_us': :'Integer',
    'concurrency_wait_time_in_us': :'Integer',
    'application_wait_time_in_us': :'Integer',
    'cluster_wait_time_in_us': :'Integer',
    'user_io_wait_time_in_us': :'Integer',
    'plsql_exec_time_in_us': :'Integer',
    'java_exec_time_in_us': :'Integer',
    'sorts': :'Integer',
    'sharable_mem': :'Integer',
    'total_sharable_mem': :'Integer',
    'type_check_mem': :'Integer',
    'io_cell_offload_eligible_bytes': :'Integer',
    'io_interconnect_bytes': :'Integer',
    'physical_read_requests': :'Integer',
    'physical_read_bytes': :'Integer',
    'physical_write_requests': :'Integer',
    'physical_write_bytes': :'Integer',
    'exact_matching_signature': :'String',
    'force_matching_signature': :'String',
    'io_cell_uncompressed_bytes': :'Integer',
    'io_cell_offload_returned_bytes': :'Integer',
    'child_number': :'Integer',
    'command_type': :'Integer',
    'users_opening': :'Integer',
    'users_executing': :'Integer',
    'optimizer_cost': :'Integer',
    'full_plan_hash_value': :'String',
    '_module': :'String',
    'service': :'String',
    'action': :'String',
    'sql_profile': :'String',
    'sql_patch': :'String',
    'sql_plan_baseline': :'String',
    'delta_execution_count': :'Integer',
    'delta_cpu_time': :'Integer',
    'delta_io_bytes': :'Integer',
    'delta_cpu_rank': :'Integer',
    'delta_execs_rank': :'Integer',
    'sharable_mem_rank': :'Integer',
    'delta_io_rank': :'Integer',
    'harmonic_sum': :'Integer',
    'wt_harmonic_sum': :'Integer',
    'total_sql_count': :'Integer'
    # rubocop:enable Style/SymbolLiteral
  }
end

Instance Method Details

#==(other) ⇒ Object

Checks equality by comparing each attribute.

Parameters:

  • other (Object) —

    the other object to be compared



889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 889

def ==(other)
  return true if equal?(other)

  self.class == other.class &&
    sql_identifier == other.sql_identifier &&
    plan_hash_value == other.plan_hash_value &&
    time_collected == other.time_collected &&
    instance_name == other.instance_name &&
    last_active_time == other.last_active_time &&
    parse_calls == other.parse_calls &&
    disk_reads == other.disk_reads &&
    direct_reads == other.direct_reads &&
    direct_writes == other.direct_writes &&
    buffer_gets == other.buffer_gets &&
    rows_processed == other.rows_processed &&
    serializable_aborts == other.serializable_aborts &&
    fetches == other.fetches &&
    executions == other.executions &&
    avoided_executions == other.avoided_executions &&
    end_of_fetch_count == other.end_of_fetch_count &&
    loads == other.loads &&
    version_count == other.version_count &&
    invalidations == other.invalidations &&
    obsolete_count == other.obsolete_count &&
    px_servers_executions == other.px_servers_executions &&
    cpu_time_in_us == other.cpu_time_in_us &&
    elapsed_time_in_us == other.elapsed_time_in_us &&
    avg_hard_parse_time_in_us == other.avg_hard_parse_time_in_us &&
    concurrency_wait_time_in_us == other.concurrency_wait_time_in_us &&
    application_wait_time_in_us == other.application_wait_time_in_us &&
    cluster_wait_time_in_us == other.cluster_wait_time_in_us &&
    user_io_wait_time_in_us == other.user_io_wait_time_in_us &&
    plsql_exec_time_in_us == other.plsql_exec_time_in_us &&
    java_exec_time_in_us == other.java_exec_time_in_us &&
    sorts == other.sorts &&
    sharable_mem == other.sharable_mem &&
    total_sharable_mem == other.total_sharable_mem &&
    type_check_mem == other.type_check_mem &&
    io_cell_offload_eligible_bytes == other.io_cell_offload_eligible_bytes &&
    io_interconnect_bytes == other.io_interconnect_bytes &&
    physical_read_requests == other.physical_read_requests &&
    physical_read_bytes == other.physical_read_bytes &&
    physical_write_requests == other.physical_write_requests &&
    physical_write_bytes == other.physical_write_bytes &&
    exact_matching_signature == other.exact_matching_signature &&
    force_matching_signature == other.force_matching_signature &&
    io_cell_uncompressed_bytes == other.io_cell_uncompressed_bytes &&
    io_cell_offload_returned_bytes == other.io_cell_offload_returned_bytes &&
    child_number == other.child_number &&
    command_type == other.command_type &&
    users_opening == other.users_opening &&
    users_executing == other.users_executing &&
    optimizer_cost == other.optimizer_cost &&
    full_plan_hash_value == other.full_plan_hash_value &&
    _module == other._module &&
    service == other.service &&
    action == other.action &&
    sql_profile == other.sql_profile &&
    sql_patch == other.sql_patch &&
    sql_plan_baseline == other.sql_plan_baseline &&
    delta_execution_count == other.delta_execution_count &&
    delta_cpu_time == other.delta_cpu_time &&
    delta_io_bytes == other.delta_io_bytes &&
    delta_cpu_rank == other.delta_cpu_rank &&
    delta_execs_rank == other.delta_execs_rank &&
    sharable_mem_rank == other.sharable_mem_rank &&
    delta_io_rank == other.delta_io_rank &&
    harmonic_sum == other.harmonic_sum &&
    wt_harmonic_sum == other.wt_harmonic_sum &&
    total_sql_count == other.total_sql_count
end

#build_from_hash(attributes) ⇒ Object

Builds the object from hash

Parameters:

  • attributes (Hash) —

    Model attributes in the form of hash

Returns:

  • (Object) —

    Returns the model itself



984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 984

def build_from_hash(attributes)
  return nil unless attributes.is_a?(Hash)

  self.class.swagger_types.each_pair do |key, type|
    if type =~ /^Array<(.*)>/i
      # check to ensure the input is an array given that the the attribute
      # is documented as an array but the input is not
      if attributes[self.class.attribute_map[key]].is_a?(Array)
        public_method("#{key}=").call(
          attributes[self.class.attribute_map[key]]
            .map { |v| OCI::Internal::Util.convert_to_type(Regexp.last_match(1), v) }
        )
      end
    elsif !attributes[self.class.attribute_map[key]].nil?
      public_method("#{key}=").call(
        OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]])
      )
    end
    # or else data not found in attributes(hash), not an issue as the data can be optional
  end

  self
end

#eql?(other) ⇒ Boolean

Parameters:

  • other (Object) —

    the other object to be compared

Returns:

  • (Boolean)

See Also:

  • `==` method


964
965
966
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 964

def eql?(other)
  self == other
end

#hash ⇒ Fixnum

Calculates hash code according to all attributes.

Returns:

  • (Fixnum) —

    Hash code



973
974
975
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 973

def hash
  [sql_identifier, plan_hash_value, time_collected, instance_name, last_active_time, parse_calls, disk_reads, direct_reads, direct_writes, buffer_gets, rows_processed, serializable_aborts, fetches, executions, avoided_executions, end_of_fetch_count, loads, version_count, invalidations, obsolete_count, px_servers_executions, cpu_time_in_us, elapsed_time_in_us, avg_hard_parse_time_in_us, concurrency_wait_time_in_us, application_wait_time_in_us, cluster_wait_time_in_us, user_io_wait_time_in_us, plsql_exec_time_in_us, java_exec_time_in_us, sorts, sharable_mem, total_sharable_mem, type_check_mem, io_cell_offload_eligible_bytes, io_interconnect_bytes, physical_read_requests, physical_read_bytes, physical_write_requests, physical_write_bytes, exact_matching_signature, force_matching_signature, io_cell_uncompressed_bytes, io_cell_offload_returned_bytes, child_number, command_type, users_opening, users_executing, optimizer_cost, full_plan_hash_value, _module, service, action, sql_profile, sql_patch, sql_plan_baseline, delta_execution_count, delta_cpu_time, delta_io_bytes, delta_cpu_rank, delta_execs_rank, sharable_mem_rank, delta_io_rank, harmonic_sum, wt_harmonic_sum, total_sql_count].hash
end

#to_hash ⇒ Hash

Returns the object in the form of hash

Returns:

  • (Hash) —

    Returns the object in the form of hash



1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 1017

def to_hash
  hash = {}
  self.class.attribute_map.each_pair do |attr, param|
    value = public_method(attr).call
    next if value.nil? && !instance_variable_defined?("@#{attr}")

    hash[param] = _to_hash(value)
  end
  hash
end

#to_s ⇒ String

Returns the string representation of the object

Returns:

  • (String) —

    String presentation of the object



1011
1012
1013
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 1011

def to_s
  to_hash.to_s
end