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



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
881
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 508

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) 


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

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) 


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

def action
  @action
end

#application_wait_time_in_us ⇒ Integer

Application wait time (in microseconds)

Returns:

  • (Integer) 


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

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) 


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

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) 


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

def avoided_executions
  @avoided_executions
end

#buffer_gets ⇒ Integer

Number of Buffer Gets

Returns:

  • (Integer) 


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

def buffer_gets
  @buffer_gets
end

#child_number ⇒ Integer

Number of this child cursor

Returns:

  • (Integer) 


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

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) 


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

def cluster_wait_time_in_us
  @cluster_wait_time_in_us
end

#command_type ⇒ Integer

Oracle command type definition

Returns:

  • (Integer) 


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

def command_type
  @command_type
end

#concurrency_wait_time_in_us ⇒ Integer

Concurrency wait time (in microseconds)

Returns:

  • (Integer) 


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

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) 


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

def cpu_time_in_us
  @cpu_time_in_us
end

#delta_cpu_rank ⇒ Integer

Rank based on CPU Consumption

Returns:

  • (Integer) 


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

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) 


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

def delta_cpu_time
  @delta_cpu_time
end

#delta_execs_rank ⇒ Integer

Rank based on number of execution

Returns:

  • (Integer) 


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

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) 


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

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) 


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

def delta_io_bytes
  @delta_io_bytes
end

#delta_io_rank ⇒ Integer

Rank based on I/O Consumption

Returns:

  • (Integer) 


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

def delta_io_rank
  @delta_io_rank
end

#direct_reads ⇒ Integer

Number of direct reads

Returns:

  • (Integer) 


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

def direct_reads
  @direct_reads
end

#direct_writes ⇒ Integer

Number of Direct writes

Returns:

  • (Integer) 


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

def direct_writes
  @direct_writes
end

#disk_reads ⇒ Integer

Number of disk reads

Returns:

  • (Integer) 


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

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) 


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

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) 


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

def end_of_fetch_count
  @end_of_fetch_count
end

#exact_matching_signature ⇒ String

exact_matching_signature Example: \"18067345456756876713\"

Returns:

  • (String) 


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

def exact_matching_signature
  @exact_matching_signature
end

#executions ⇒ Integer

Number of executions

Returns:

  • (Integer) 


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

def executions
  @executions
end

#fetches ⇒ Integer

Number of fetches

Returns:

  • (Integer) 


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

def fetches
  @fetches
end

#force_matching_signature ⇒ String

force_matching_signature Example: \"18067345456756876713\"

Returns:

  • (String) 


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

def force_matching_signature
  @force_matching_signature
end

#full_plan_hash_value ⇒ String

Total Number of rows in SQLStats table

Returns:

  • (String) 


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

def full_plan_hash_value
  @full_plan_hash_value
end

#harmonic_sum ⇒ Integer

Harmonic sum based on ranking parameters

Returns:

  • (Integer) 


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

def harmonic_sum
  @harmonic_sum
end

#instance_name ⇒ String

[Required] Name of Database Instance Example: \"DB10902_1\"

Returns:

  • (String) 


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

def instance_name
  @instance_name
end

#invalidations ⇒ Integer

Number of times this child cursor has been invalidated

Returns:

  • (Integer) 


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

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) 


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

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) 


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

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) 


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

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) 


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

def io_interconnect_bytes
  @io_interconnect_bytes
end

#java_exec_time_in_us ⇒ Integer

Java execution time (in microseconds)

Returns:

  • (Integer) 


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

def java_exec_time_in_us
  @java_exec_time_in_us
end

#last_active_time ⇒ String

last_active_time Example: \"0000000099CCE300\"

Returns:

  • (String) 


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

def last_active_time
  @last_active_time
end

#loads ⇒ Integer

Number of times the object was either loaded or reloaded

Returns:

  • (Integer) 


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

def loads
  @loads
end

#obsolete_count ⇒ Integer

Number of times that a parent cursor became obsolete

Returns:

  • (Integer) 


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

def obsolete_count
  @obsolete_count
end

#optimizer_cost ⇒ Integer

Cost of this query given by the optimizer

Returns:

  • (Integer) 


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

def optimizer_cost
  @optimizer_cost
end

#parse_calls ⇒ Integer

Total integer of parse calls Example: 60

Returns:

  • (Integer) 


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

def parse_calls
  @parse_calls
end

#physical_read_bytes ⇒ Integer

Number of bytes read from disks by the monitored SQL

Returns:

  • (Integer) 


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

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) 


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

def physical_read_requests
  @physical_read_requests
end

#physical_write_bytes ⇒ Integer

Number of bytes written to disks by the monitored SQL

Returns:

  • (Integer) 


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

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) 


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

def physical_write_requests
  @physical_write_requests
end

#plan_hash_value ⇒ Integer

[Required] Plan hash value for the SQL Execution Plan

Returns:

  • (Integer) 


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

def plan_hash_value
  @plan_hash_value
end

#plsql_exec_time_in_us ⇒ Integer

PL/SQL execution time (in microseconds)

Returns:

  • (Integer) 


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

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) 


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

def px_servers_executions
  @px_servers_executions
end

#rows_processed ⇒ Integer

Number of row processed

Returns:

  • (Integer) 


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

def rows_processed
  @rows_processed
end

#serializable_aborts ⇒ Integer

Number of serializable aborts

Returns:

  • (Integer) 


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

def serializable_aborts
  @serializable_aborts
end

#service ⇒ String

Service name

Returns:

  • (String) 


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

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) 


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

def sharable_mem
  @sharable_mem
end

#sharable_mem_rank ⇒ Integer

Rank based on sharable memory

Returns:

  • (Integer) 


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

def sharable_mem_rank
  @sharable_mem_rank
end

#sorts ⇒ Integer

Number of sorts that were done for the child cursor

Returns:

  • (Integer) 


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

def sorts
  @sorts
end

#sql_identifier ⇒ String

[Required] Unique SQL_ID for a SQL Statement.

Returns:

  • (String) 


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

def sql_identifier
  @sql_identifier
end

#sql_patch ⇒ String

SQL patch used for this statement, if any

Returns:

  • (String) 


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

def sql_patch
  @sql_patch
end

#sql_plan_baseline ⇒ String

SQL plan baseline used for this statement, if any

Returns:

  • (String) 


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

def sql_plan_baseline
  @sql_plan_baseline
end

#sql_profile ⇒ String

SQL profile used for this statement, if any

Returns:

  • (String) 


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

def sql_profile
  @sql_profile
end

#time_collected ⇒ DateTime

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

Returns:

  • (DateTime) 


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

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) 


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

def total_sharable_mem
  @total_sharable_mem
end

#total_sql_count ⇒ Integer

Total number of rows in SQLStats table

Returns:

  • (Integer) 


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

def total_sql_count
  @total_sql_count
end

#type_check_mem ⇒ Integer

Typecheck memory

Returns:

  • (Integer) 


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

def type_check_mem
  @type_check_mem
end

#user_io_wait_time_in_us ⇒ Integer

User I/O wait time (in microseconds)

Returns:

  • (Integer) 


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

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) 


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

def users_executing
  @users_executing
end

#users_opening ⇒ Integer

Number of users that have any of the child cursors open

Returns:

  • (Integer) 


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

def users_opening
  @users_opening
end

#version_count ⇒ Integer

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

Returns:

  • (Integer) 


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

def version_count
  @version_count
end

#wt_harmonic_sum ⇒ Integer

Weight based harmonic sum of ranking parameters

Returns:

  • (Integer) 


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

def wt_harmonic_sum
  @wt_harmonic_sum
end

Class Method Details

.attribute_map ⇒ Object

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



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
360
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 289

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.



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
434
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 363

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



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
960
 
# File 'lib/oci/opsi/models/sql_stats.rb', line 890

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



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

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


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

def eql?(other)
  self == other
end

#hash ⇒ Fixnum

Calculates hash code according to all attributes.

Returns:

  • (Fixnum) —

    Hash code



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

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



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

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



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

def to_s
  to_hash.to_s
end