← Index
NYTProf Performance Profile   « block view • line view • sub view »
For xt/tapper-mcp-scheduler-with-db-longrun.t
  Run on Tue May 22 17:18:39 2012
Reported on Tue May 22 17:22:37 2012

Filename/2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/site_perl/5.12.3/DBIx/Class/Storage/DBI.pm
StatementsExecuted 1036527 statements in 155s
Subroutines
Calls P F Exclusive
Time
Inclusive
Time
Subroutine
801911460ms8.62sDBIx::Class::Storage::DBI::::_gen_sql_bindDBIx::Class::Storage::DBI::_gen_sql_bind
2228662376ms132sDBIx::Class::Storage::DBI::::dbh_doDBIx::Class::Storage::DBI::dbh_do (recurses: max depth 2, inclusive time 1.61s)
801921349ms118sDBIx::Class::Storage::DBI::::_dbh_executeDBIx::Class::Storage::DBI::_dbh_execute
670611257ms1.00sDBIx::Class::Storage::DBI::::_select_argsDBIx::Class::Storage::DBI::_select_args
801941159ms127sDBIx::Class::Storage::DBI::::_executeDBIx::Class::Storage::DBI::_execute
2258841154ms254msDBIx::Class::Storage::DBI::::_get_dbhDBIx::Class::Storage::DBI::_get_dbh
801911142ms142msDBIx::Class::Storage::DBI::::_dbi_attrs_for_bindDBIx::Class::Storage::DBI::_dbi_attrs_for_bind
1115311123ms2.29sDBIx::Class::Storage::DBI::::__ANON__[:1443]DBIx::Class::Storage::DBI::__ANON__[:1443]
3365662118ms133msDBIx::Class::Storage::DBI::::sql_makerDBIx::Class::Storage::DBI::sql_maker
80191189.7ms472msDBIx::Class::Storage::DBI::::_dbh_sthDBIx::Class::Storage::DBI::_dbh_sth
40142289.0ms3.53sDBIx::Class::Storage::DBI::::select_singleDBIx::Class::Storage::DBI::select_single
94003285.3ms346msDBIx::Class::Storage::DBI::::selectDBIx::Class::Storage::DBI::select
228904179.8ms80.0msDBIx::Class::Storage::DBI::::_verify_pidDBIx::Class::Storage::DBI::_verify_pid
8982278.2ms36.2sDBIx::Class::Storage::DBI::::insertDBIx::Class::Storage::DBI::insert
140043374.5ms288msDBIx::Class::Storage::DBI::::get_use_dbms_capabilityDBIx::Class::Storage::DBI::get_use_dbms_capability
67063266.9ms9.96sDBIx::Class::Storage::DBI::::_selectDBIx::Class::Storage::DBI::_select
92742165.1ms132sDBIx::Class::Storage::DBI::::__ANON__[:790]DBIx::Class::Storage::DBI::__ANON__[:790]
80191156.7ms652msDBIx::Class::Storage::DBI::::_sthDBIx::Class::Storage::DBI::_sth
80191154.7ms8.68sDBIx::Class::Storage::DBI::::_prep_for_executeDBIx::Class::Storage::DBI::_prep_for_execute
80882154.2ms54.2msDBIx::Class::Storage::DBI::::_query_endDBIx::Class::Storage::DBI::_query_end
80902134.6ms35.4msDBIx::Class::Storage::DBI::::_query_startDBIx::Class::Storage::DBI::_query_start
16902215.8ms80.5sDBIx::Class::Storage::DBI::::updateDBIx::Class::Storage::DBI::update
4491112.9ms36.4msDBIx::Class::Storage::DBI::::_prefetch_autovaluesDBIx::Class::Storage::DBI::_prefetch_autovalues
2941110.6ms34.9sDBIx::Class::Storage::DBI::::txn_commitDBIx::Class::Storage::DBI::txn_commit
61110.3ms19.4msDBIx::Class::Storage::DBI::::__ANON__[:1300]DBIx::Class::Storage::DBI::__ANON__[:1300]
294119.80ms34.8sDBIx::Class::Storage::DBI::::_exec_txn_commitDBIx::Class::Storage::DBI::_exec_txn_commit
588228.34ms61.8msDBIx::Class::Storage::DBI::::txn_beginDBIx::Class::Storage::DBI::txn_begin
1949117.59ms7.59msDBIx::Class::Storage::DBI::::_count_selectDBIx::Class::Storage::DBI::_count_select
79117.38ms7.96sDBIx::Class::Storage::DBI::::__ANON__[:2767]DBIx::Class::Storage::DBI::__ANON__[:2767]
296115.42ms19.8msDBIx::Class::Storage::DBI::::_dbh_last_insert_idDBIx::Class::Storage::DBI::_dbh_last_insert_id
592214.08ms4.10msDBIx::Class::Storage::DBI::::get_dbms_capabilityDBIx::Class::Storage::DBI::get_dbms_capability
296113.85ms5.91msDBIx::Class::Storage::DBI::::__ANON__[:2358]DBIx::Class::Storage::DBI::__ANON__[:2358]
296113.72ms23.5msDBIx::Class::Storage::DBI::::last_insert_idDBIx::Class::Storage::DBI::last_insert_id
294113.34ms38.5msDBIx::Class::Storage::DBI::::_exec_txn_beginDBIx::Class::Storage::DBI::_exec_txn_begin
296112.94ms2.94msDBIx::Class::Storage::DBI::::CORE:substDBIx::Class::Storage::DBI::CORE:subst (opcode)
294111.95ms14.3msDBIx::Class::Storage::DBI::::__ANON__[:1339]DBIx::Class::Storage::DBI::__ANON__[:1339]
322811.59ms1.59msDBIx::Class::Storage::DBI::::CORE:matchDBIx::Class::Storage::DBI::CORE:match (opcode)
294221.53ms12.3msDBIx::Class::Storage::DBI::::datetime_parserDBIx::Class::Storage::DBI::datetime_parser
71111.32ms7.94sDBIx::Class::Storage::DBI::::__ANON__[:2763]DBIx::Class::Storage::DBI::__ANON__[:2763]
71111.23ms7.93sDBIx::Class::Storage::DBI::::__ANON__[:2762]DBIx::Class::Storage::DBI::__ANON__[:2762]
4111.08ms8.22sDBIx::Class::Storage::DBI::::deployDBIx::Class::Storage::DBI::deploy
294221.03ms1.03msDBIx::Class::Storage::DBI::::relname_to_table_aliasDBIx::Class::Storage::DBI::relname_to_table_alias
3822470µs2.15sDBIx::Class::Storage::DBI::::deleteDBIx::Class::Storage::DBI::delete
1331445µs2.66msDBIx::Class::Storage::DBI::::_determine_driverDBIx::Class::Storage::DBI::_determine_driver
1033324µs238msDBIx::Class::Storage::DBI::::deployment_statementsDBIx::Class::Storage::DBI::deployment_statements
611265µs20.2msDBIx::Class::Storage::DBI::::_connectDBIx::Class::Storage::DBI::_connect
922225µs752µsDBIx::Class::Storage::DBI::::connect_infoDBIx::Class::Storage::DBI::connect_info
611209µs20.7msDBIx::Class::Storage::DBI::::_populate_dbhDBIx::Class::Storage::DBI::_populate_dbh
822174µs18.3msDBIx::Class::Storage::DBI::::_server_infoDBIx::Class::Storage::DBI::_server_info
611118µs144µsDBIx::Class::Storage::DBI::::__ANON__[:1298]DBIx::Class::Storage::DBI::__ANON__[:1298]
611111µs709µsDBIx::Class::Storage::DBI::::newDBIx::Class::Storage::DBI::new
611103µs103µsDBIx::Class::Storage::DBI::::_normalize_connect_infoDBIx::Class::Storage::DBI::_normalize_connect_info
61181µs326µsDBIx::Class::Storage::DBI::::_run_connection_actionsDBIx::Class::Storage::DBI::_run_connection_actions
21168µs212µsDBIx::Class::Storage::DBI::::connectedDBIx::Class::Storage::DBI::connected
11166µs106µsDBIx::Class::Storage::DBI::::ENDDBIx::Class::Storage::DBI::END
82160µs110µsDBIx::Class::Storage::DBI::::sqlt_typeDBIx::Class::Storage::DBI::sqlt_type
61145µs59µsDBIx::Class::Storage::DBI::::_arm_global_destructorDBIx::Class::Storage::DBI::_arm_global_destructor
61143µs139µsDBIx::Class::Storage::DBI::::_parse_connect_doDBIx::Class::Storage::DBI::_parse_connect_do
41135µs17.9msDBIx::Class::Storage::DBI::::__ANON__[:1116]DBIx::Class::Storage::DBI::__ANON__[:1116]
41133µs33µsDBIx::Class::Storage::DBI::::CORE:ftfileDBIx::Class::Storage::DBI::CORE:ftfile (opcode)
41133µs18.0msDBIx::Class::Storage::DBI::::_dbh_get_infoDBIx::Class::Storage::DBI::_dbh_get_info
82132µs18.0msDBIx::Class::Storage::DBI::::_get_server_versionDBIx::Class::Storage::DBI::_get_server_version
41132µs18.0msDBIx::Class::Storage::DBI::::__ANON__[:1078]DBIx::Class::Storage::DBI::__ANON__[:1078]
21129µs4.63msDBIx::Class::Storage::DBI::::__ANON__[:1297]DBIx::Class::Storage::DBI::__ANON__[:1297]
31126µs42µsDBIx::Class::Storage::DBI::::is_datatype_numericDBIx::Class::Storage::DBI::is_datatype_numeric
21125µs43µsDBIx::Class::Storage::DBI::::_seems_connectedDBIx::Class::Storage::DBI::_seems_connected
21124µs357µsDBIx::Class::Storage::DBI::::__ANON__[:800]DBIx::Class::Storage::DBI::__ANON__[:800]
61118µs18µsDBIx::Class::Storage::DBI::::_default_dbi_connect_attributesDBIx::Class::Storage::DBI::_default_dbi_connect_attributes
11117µs22µsDBIx::Class::Storage::DBI::::BEGIN@4DBIx::Class::Storage::DBI::BEGIN@4
21115µs89µsDBIx::Class::Storage::DBI::::_pingDBIx::Class::Storage::DBI::_ping
22115µs10.8msDBIx::Class::Storage::DBI::::build_datetime_parserDBIx::Class::Storage::DBI::build_datetime_parser
11114µs39µsDBIx::Class::Storage::DBI::::BEGIN@1407DBIx::Class::Storage::DBI::BEGIN@1407
61113µs13µsDBIx::Class::Storage::DBI::::_reblessDBIx::Class::Storage::DBI::_rebless
61111µs11µsDBIx::Class::Storage::DBI::::__ANON__[:1306]DBIx::Class::Storage::DBI::__ANON__[:1306]
11110µs29µsDBIx::Class::Storage::DBI::::BEGIN@110DBIx::Class::Storage::DBI::BEGIN@110
6119µs9µsDBIx::Class::Storage::DBI::::_initDBIx::Class::Storage::DBI::_init
1119µs8.73msDBIx::Class::Storage::DBI::::BEGIN@7DBIx::Class::Storage::DBI::BEGIN@7
1119µs62µsDBIx::Class::Storage::DBI::::BEGIN@12DBIx::Class::Storage::DBI::BEGIN@12
1119µs90µsDBIx::Class::Storage::DBI::::BEGIN@10DBIx::Class::Storage::DBI::BEGIN@10
1119µs26µsDBIx::Class::Storage::DBI::::BEGIN@5DBIx::Class::Storage::DBI::BEGIN@5
1119µs18µsDBIx::Class::Storage::DBI::::BEGIN@8DBIx::Class::Storage::DBI::BEGIN@8
1119µs41µsDBIx::Class::Storage::DBI::::BEGIN@15DBIx::Class::Storage::DBI::BEGIN@15
1118µs20µsDBIx::Class::Storage::DBI::::BEGIN@109DBIx::Class::Storage::DBI::BEGIN@109
1118µs246µsDBIx::Class::Storage::DBI::::BEGIN@17DBIx::Class::Storage::DBI::BEGIN@17
1117µs26µsDBIx::Class::Storage::DBI::::BEGIN@13DBIx::Class::Storage::DBI::BEGIN@13
1117µs7µsDBIx::Class::Storage::DBI::::BEGIN@11DBIx::Class::Storage::DBI::BEGIN@11
1117µs25µsDBIx::Class::Storage::DBI::::BEGIN@14DBIx::Class::Storage::DBI::BEGIN@14
1116µs7µsDBIx::Class::Storage::DBI::::set_dbms_capabilityDBIx::Class::Storage::DBI::set_dbms_capability
1116µs13µsDBIx::Class::Storage::DBI::::set_use_dbms_capabilityDBIx::Class::Storage::DBI::set_use_dbms_capability
4324µs4µsDBIx::Class::Storage::DBI::::schemaDBIx::Class::Storage::DBI::schema (xsub)
1114µs4µsDBIx::Class::Storage::DBI::::BEGIN@16DBIx::Class::Storage::DBI::BEGIN@16
0000s0sDBIx::Class::Storage::DBI::::CLONEDBIx::Class::Storage::DBI::CLONE
0000s0sDBIx::Class::Storage::DBI::::DESTROYDBIx::Class::Storage::DBI::DESTROY
0000s0sDBIx::Class::Storage::DBI::::__ANON__[:1303]DBIx::Class::Storage::DBI::__ANON__[:1303]
0000s0sDBIx::Class::Storage::DBI::::__ANON__[:132]DBIx::Class::Storage::DBI::__ANON__[:132]
0000s0sDBIx::Class::Storage::DBI::::__ANON__[:1414]DBIx::Class::Storage::DBI::__ANON__[:1414]
0000s0sDBIx::Class::Storage::DBI::::__ANON__[:1455]DBIx::Class::Storage::DBI::__ANON__[:1455]
0000s0sDBIx::Class::Storage::DBI::::__ANON__[:1676]DBIx::Class::Storage::DBI::__ANON__[:1676]
0000s0sDBIx::Class::Storage::DBI::::__ANON__[:1680]DBIx::Class::Storage::DBI::__ANON__[:1680]
0000s0sDBIx::Class::Storage::DBI::::__ANON__[:1772]DBIx::Class::Storage::DBI::__ANON__[:1772]
0000s0sDBIx::Class::Storage::DBI::::__ANON__[:1903]DBIx::Class::Storage::DBI::__ANON__[:1903]
0000s0sDBIx::Class::Storage::DBI::::__ANON__[:1906]DBIx::Class::Storage::DBI::__ANON__[:1906]
0000s0sDBIx::Class::Storage::DBI::::__ANON__[:1919]DBIx::Class::Storage::DBI::__ANON__[:1919]
0000s0sDBIx::Class::Storage::DBI::::__ANON__[:1922]DBIx::Class::Storage::DBI::__ANON__[:1922]
0000s0sDBIx::Class::Storage::DBI::::__ANON__[:1956]DBIx::Class::Storage::DBI::__ANON__[:1956]
0000s0sDBIx::Class::Storage::DBI::::__ANON__[:1959]DBIx::Class::Storage::DBI::__ANON__[:1959]
0000s0sDBIx::Class::Storage::DBI::::__ANON__[:1964]DBIx::Class::Storage::DBI::__ANON__[:1964]
0000s0sDBIx::Class::Storage::DBI::::__ANON__[:1967]DBIx::Class::Storage::DBI::__ANON__[:1967]
0000s0sDBIx::Class::Storage::DBI::::__ANON__[:228]DBIx::Class::Storage::DBI::__ANON__[:228]
0000s0sDBIx::Class::Storage::DBI::::__ANON__[:2305]DBIx::Class::Storage::DBI::__ANON__[:2305]
0000s0sDBIx::Class::Storage::DBI::::__ANON__[:2307]DBIx::Class::Storage::DBI::__ANON__[:2307]
0000s0sDBIx::Class::Storage::DBI::::__ANON__[:2414]DBIx::Class::Storage::DBI::__ANON__[:2414]
0000s0sDBIx::Class::Storage::DBI::::__ANON__[:2417]DBIx::Class::Storage::DBI::__ANON__[:2417]
0000s0sDBIx::Class::Storage::DBI::::__ANON__[:2432]DBIx::Class::Storage::DBI::__ANON__[:2432]
0000s0sDBIx::Class::Storage::DBI::::__ANON__[:2435]DBIx::Class::Storage::DBI::__ANON__[:2435]
0000s0sDBIx::Class::Storage::DBI::::__ANON__[:2765]DBIx::Class::Storage::DBI::__ANON__[:2765]
0000s0sDBIx::Class::Storage::DBI::::_dbh_columns_info_forDBIx::Class::Storage::DBI::_dbh_columns_info_for
0000s0sDBIx::Class::Storage::DBI::::_dbh_execute_arrayDBIx::Class::Storage::DBI::_dbh_execute_array
0000s0sDBIx::Class::Storage::DBI::::_dbh_execute_inserts_with_no_bindsDBIx::Class::Storage::DBI::_dbh_execute_inserts_with_no_binds
0000s0sDBIx::Class::Storage::DBI::::_determine_supports_join_optimizerDBIx::Class::Storage::DBI::_determine_supports_join_optimizer
0000s0sDBIx::Class::Storage::DBI::::_determine_supports_placeholdersDBIx::Class::Storage::DBI::_determine_supports_placeholders
0000s0sDBIx::Class::Storage::DBI::::_determine_supports_typeless_placeholdersDBIx::Class::Storage::DBI::_determine_supports_typeless_placeholders
0000s0sDBIx::Class::Storage::DBI::::_do_connection_actionsDBIx::Class::Storage::DBI::_do_connection_actions
0000s0sDBIx::Class::Storage::DBI::::_do_queryDBIx::Class::Storage::DBI::_do_query
0000s0sDBIx::Class::Storage::DBI::::_exec_txn_rollbackDBIx::Class::Storage::DBI::_exec_txn_rollback
0000s0sDBIx::Class::Storage::DBI::::_execute_arrayDBIx::Class::Storage::DBI::_execute_array
0000s0sDBIx::Class::Storage::DBI::::_format_for_traceDBIx::Class::Storage::DBI::_format_for_trace
0000s0sDBIx::Class::Storage::DBI::::_is_binary_lob_typeDBIx::Class::Storage::DBI::_is_binary_lob_type
0000s0sDBIx::Class::Storage::DBI::::_is_lob_typeDBIx::Class::Storage::DBI::_is_lob_type
0000s0sDBIx::Class::Storage::DBI::::_is_text_lob_typeDBIx::Class::Storage::DBI::_is_text_lob_type
0000s0sDBIx::Class::Storage::DBI::::_max_column_bytesizeDBIx::Class::Storage::DBI::_max_column_bytesize
0000s0sDBIx::Class::Storage::DBI::::_multipk_update_deleteDBIx::Class::Storage::DBI::_multipk_update_delete
0000s0sDBIx::Class::Storage::DBI::::_native_data_typeDBIx::Class::Storage::DBI::_native_data_type
0000s0sDBIx::Class::Storage::DBI::::_per_row_update_deleteDBIx::Class::Storage::DBI::_per_row_update_delete
0000s0sDBIx::Class::Storage::DBI::::_select_args_to_queryDBIx::Class::Storage::DBI::_select_args_to_query
0000s0sDBIx::Class::Storage::DBI::::_subq_update_deleteDBIx::Class::Storage::DBI::_subq_update_delete
0000s0sDBIx::Class::Storage::DBI::::bind_attribute_by_data_typeDBIx::Class::Storage::DBI::bind_attribute_by_data_type
0000s0sDBIx::Class::Storage::DBI::::columns_info_forDBIx::Class::Storage::DBI::columns_info_for
0000s0sDBIx::Class::Storage::DBI::::connect_call_datetime_setupDBIx::Class::Storage::DBI::connect_call_datetime_setup
0000s0sDBIx::Class::Storage::DBI::::connect_call_do_sqlDBIx::Class::Storage::DBI::connect_call_do_sql
0000s0sDBIx::Class::Storage::DBI::::create_ddl_dirDBIx::Class::Storage::DBI::create_ddl_dir
0000s0sDBIx::Class::Storage::DBI::::dbhDBIx::Class::Storage::DBI::dbh
0000s0sDBIx::Class::Storage::DBI::::disconnectDBIx::Class::Storage::DBI::disconnect
0000s0sDBIx::Class::Storage::DBI::::disconnect_call_do_sqlDBIx::Class::Storage::DBI::disconnect_call_do_sql
0000s0sDBIx::Class::Storage::DBI::::ensure_connectedDBIx::Class::Storage::DBI::ensure_connected
0000s0sDBIx::Class::Storage::DBI::::insert_bulkDBIx::Class::Storage::DBI::insert_bulk
0000s0sDBIx::Class::Storage::DBI::::is_replicatingDBIx::Class::Storage::DBI::is_replicating
0000s0sDBIx::Class::Storage::DBI::::lag_behind_masterDBIx::Class::Storage::DBI::lag_behind_master
0000s0sDBIx::Class::Storage::DBI::::source_bind_attributesDBIx::Class::Storage::DBI::source_bind_attributes
0000s0sDBIx::Class::Storage::DBI::::sthDBIx::Class::Storage::DBI::sth
0000s0sDBIx::Class::Storage::DBI::::txn_doDBIx::Class::Storage::DBI::txn_do
0000s0sDBIx::Class::Storage::DBI::::txn_rollbackDBIx::Class::Storage::DBI::txn_rollback
0000s0sDBIx::Class::Storage::DBI::::with_deferred_fk_checksDBIx::Class::Storage::DBI::with_deferred_fk_checks
Call graph for these subroutines as a Graphviz dot language file.
Line State
ments
Time
on line
Calls Time
in subs
Code
1package DBIx::Class::Storage::DBI;
2# -*- mode: cperl; cperl-indent-level: 2 -*-
3
4322µs228µs
# spent 22µs (17+5) within DBIx::Class::Storage::DBI::BEGIN@4 which was called: # once (17µs+5µs) by Class::C3::Componentised::ensure_class_loaded at line 4
use strict;
# spent 22µs making 1 call to DBIx::Class::Storage::DBI::BEGIN@4 # spent 5µs making 1 call to strict::import
5326µs243µs
# spent 26µs (9+17) within DBIx::Class::Storage::DBI::BEGIN@5 which was called: # once (9µs+17µs) by Class::C3::Componentised::ensure_class_loaded at line 5
use warnings;
# spent 26µs making 1 call to DBIx::Class::Storage::DBI::BEGIN@5 # spent 17µs making 1 call to warnings::import
6
7330µs217.5ms
# spent 8.73ms (9µs+8.73) within DBIx::Class::Storage::DBI::BEGIN@7 which was called: # once (9µs+8.73ms) by Class::C3::Componentised::ensure_class_loaded at line 7
use base qw/DBIx::Class::Storage::DBIHacks DBIx::Class::Storage/;
# spent 8.73ms making 1 call to DBIx::Class::Storage::DBI::BEGIN@7 # spent 8.73ms making 1 call to base::import
8321µs227µs
# spent 18µs (9+9) within DBIx::Class::Storage::DBI::BEGIN@8 which was called: # once (9µs+9µs) by Class::C3::Componentised::ensure_class_loaded at line 8
use mro 'c3';
# spent 18µs making 1 call to DBIx::Class::Storage::DBI::BEGIN@8 # spent 9µs making 1 call to mro::import
9
10324µs2172µs
# spent 90µs (9+81) within DBIx::Class::Storage::DBI::BEGIN@10 which was called: # once (9µs+81µs) by Class::C3::Componentised::ensure_class_loaded at line 10
use DBIx::Class::Carp;
# spent 90µs making 1 call to DBIx::Class::Storage::DBI::BEGIN@10 # spent 81µs making 1 call to DBIx::Class::Carp::import
11322µs17µs
# spent 7µs within DBIx::Class::Storage::DBI::BEGIN@11 which was called: # once (7µs+0s) by Class::C3::Componentised::ensure_class_loaded at line 11
use DBIx::Class::Exception;
# spent 7µs making 1 call to DBIx::Class::Storage::DBI::BEGIN@11
12322µs2115µs
# spent 62µs (9+53) within DBIx::Class::Storage::DBI::BEGIN@12 which was called: # once (9µs+53µs) by Class::C3::Componentised::ensure_class_loaded at line 12
use Scalar::Util qw/refaddr weaken reftype blessed/;
# spent 62µs making 1 call to DBIx::Class::Storage::DBI::BEGIN@12 # spent 53µs making 1 call to Exporter::import
13318µs245µs
# spent 26µs (7+19) within DBIx::Class::Storage::DBI::BEGIN@13 which was called: # once (7µs+19µs) by Class::C3::Componentised::ensure_class_loaded at line 13
use List::Util qw/first/;
# spent 26µs making 1 call to DBIx::Class::Storage::DBI::BEGIN@13 # spent 19µs making 1 call to Exporter::import
14317µs244µs
# spent 25µs (7+19) within DBIx::Class::Storage::DBI::BEGIN@14 which was called: # once (7µs+19µs) by Class::C3::Componentised::ensure_class_loaded at line 14
use Sub::Name 'subname';
# spent 25µs making 1 call to DBIx::Class::Storage::DBI::BEGIN@14 # spent 19µs making 1 call to Exporter::import
15318µs274µs
# spent 41µs (9+33) within DBIx::Class::Storage::DBI::BEGIN@15 which was called: # once (9µs+33µs) by Class::C3::Componentised::ensure_class_loaded at line 15
use Try::Tiny;
# spent 41µs making 1 call to DBIx::Class::Storage::DBI::BEGIN@15 # spent 33µs making 1 call to Exporter::import
16316µs14µs
# spent 4µs within DBIx::Class::Storage::DBI::BEGIN@16 which was called: # once (4µs+0s) by Class::C3::Componentised::ensure_class_loaded at line 16
use overload ();
# spent 4µs making 1 call to DBIx::Class::Storage::DBI::BEGIN@16
173205µs2484µs
# spent 246µs (8+238) within DBIx::Class::Storage::DBI::BEGIN@17 which was called: # once (8µs+238µs) by Class::C3::Componentised::ensure_class_loaded at line 17
use namespace::clean;
# spent 246µs making 1 call to DBIx::Class::Storage::DBI::BEGIN@17 # spent 238µs making 1 call to namespace::clean::import
18
19# default cursor class, overridable in connect_info attributes
20113µs150µs__PACKAGE__->cursor_class('DBIx::Class::Storage::DBI::Cursor');
# spent 50µs making 1 call to DBIx::Class::Storage::cursor_class
21
2219µs1463µs__PACKAGE__->mk_group_accessors('inherited' => qw/
# spent 463µs making 1 call to Class::Accessor::Grouped::mk_group_accessors
23 sql_limit_dialect sql_quote_char sql_name_sep
24/);
25
2612µs1276µs__PACKAGE__->mk_group_accessors('component_class' => qw/sql_maker_class datetime_parser_type/);
# spent 276µs making 1 call to Class::Accessor::Grouped::mk_group_accessors
27
2811µs115µs__PACKAGE__->sql_maker_class('DBIx::Class::SQLMaker');
# spent 15µs making 1 call to DBIx::Class::Storage::DBI::sql_maker_class
2911µs112µs__PACKAGE__->datetime_parser_type('DateTime::Format::MySQL'); # historic default
30
3111µs111µs__PACKAGE__->sql_name_sep('.');
# spent 11µs making 1 call to DBIx::Class::Storage::DBI::sql_name_sep
32
3312µs1530µs__PACKAGE__->mk_group_accessors('simple' => qw/
# spent 530µs making 1 call to Class::Accessor::Grouped::mk_group_accessors
34 _connect_info _dbi_connect_info _dbic_connect_attributes _driver_determined
35 _dbh _dbh_details _conn_pid _sql_maker _sql_maker_opts _dbh_autocommit
36/);
37
38# the values for these accessors are picked out (and deleted) from
39# the attribute hashref passed to connect_info
4012µsmy @storage_options = qw/
41 on_connect_call on_disconnect_call on_connect_do on_disconnect_do
42 disable_sth_caching unsafe auto_savepoint
43/;
4412µs1353µs__PACKAGE__->mk_group_accessors('simple' => @storage_options);
# spent 353µs making 1 call to Class::Accessor::Grouped::mk_group_accessors
45
46
47# capability definitions, using a 2-tiered accessor system
48# The rationale is:
49#
50# A driver/user may define _use_X, which blindly without any checks says:
51# "(do not) use this capability", (use_dbms_capability is an "inherited"
52# type accessor)
53#
54# If _use_X is undef, _supports_X is then queried. This is a "simple" style
55# accessor, which in turn calls _determine_supports_X, and stores the return
56# in a special slot on the storage object, which is wiped every time a $dbh
57# reconnection takes place (it is not guaranteed that upon reconnection we
58# will get the same rdbms version). _determine_supports_X does not need to
59# exist on a driver, as we ->can for it before calling.
60
6112µsmy @capabilities = (qw/
62 insert_returning
63 insert_returning_bound
64 placeholders
65 typeless_placeholders
66 join_optimizer
67/);
6815µs1610µs__PACKAGE__->mk_group_accessors( dbms_capability => map { "_supports_$_" } @capabilities );
# spent 610µs making 1 call to Class::Accessor::Grouped::mk_group_accessors
6914µs1595µs__PACKAGE__->mk_group_accessors( use_dbms_capability => map { "_use_$_" } (@capabilities ) );
# spent 595µs making 1 call to Class::Accessor::Grouped::mk_group_accessors
70
71# on by default, not strictly a capability (pending rewrite)
7212µs118µs__PACKAGE__->_use_join_optimizer (1);
# spent 18µs making 1 call to DBIx::Class::Storage::DBI::_use_join_optimizer
73sub _determine_supports_join_optimizer { 1 };
74
75# Each of these methods need _determine_driver called before itself
76# in order to function reliably. This is a purely DRY optimization
77#
78# get_(use)_dbms_capability need to be called on the correct Storage
79# class, as _use_X may be hardcoded class-wide, and _supports_X calls
80# _determine_supports_X which obv. needs a correct driver as well
8114µsmy @rdbms_specific_methods = qw/
82 deployment_statements
83 sqlt_type
84 sql_maker
85 build_datetime_parser
86 datetime_parser_type
87
88 txn_begin
89 insert
90 insert_bulk
91 update
92 delete
93 select
94 select_single
95 with_deferred_fk_checks
96
97 get_use_dbms_capability
98 get_dbms_capability
99
100 _server_info
101 _get_server_version
102/;
103
10411µsfor my $meth (@rdbms_specific_methods) {
105
1061757µs1727µs my $orig = __PACKAGE__->can ($meth)
# spent 27µs making 17 calls to UNIVERSAL::can, avg 2µs/call
107 or die "$meth is not a ::Storage::DBI method!";
108
109324µs232µs
# spent 20µs (8+12) within DBIx::Class::Storage::DBI::BEGIN@109 which was called: # once (8µs+12µs) by Class::C3::Componentised::ensure_class_loaded at line 109
no strict qw/refs/;
# spent 20µs making 1 call to DBIx::Class::Storage::DBI::BEGIN@109 # spent 12µs making 1 call to strict::unimport
11033.23ms248µs
# spent 29µs (10+19) within DBIx::Class::Storage::DBI::BEGIN@110 which was called: # once (10µs+19µs) by Class::C3::Componentised::ensure_class_loaded at line 110
no warnings qw/redefine/;
# spent 29µs making 1 call to DBIx::Class::Storage::DBI::BEGIN@110 # spent 19µs making 1 call to warnings::unimport
111 *{__PACKAGE__ ."::$meth"} = subname $meth => sub {
11264938259ms2111µs if (
# spent 111µs making 2 calls to DBIx::Class::Storage::DBI::_driver_determined, avg 55µs/call
113 # only fire when invoked on an instance, a valid class-based invocation
114 # would e.g. be setting a default for an inherited accessor
115 ref $_[0]
116 and
117 ! $_[0]->_driver_determined
118 and
119 ! $_[0]->{_in_determine_driver}
120 ) {
12162.63ms $_[0]->_determine_driver;
# spent 2.63ms making 6 calls to DBIx::Class::Storage::DBI::_determine_driver, avg 439µs/call
122
123 # This for some reason crashes and burns on perl 5.8.1
124 # IFF the method ends up throwing an exception
125 #goto $_[0]->can ($meth);
126
127624µs my $cref = $_[0]->can ($meth);
# spent 24µs making 6 calls to UNIVERSAL::can, avg 4µs/call
1286247ms goto $cref;
# spent 247ms making 2 calls to DBIx::Class::Storage::DBI::SQLite::deployment_statements, avg 123ms/call # spent 13µs making 2 calls to DBIx::Class::Storage::DBI::sql_maker, avg 7µs/call # spent 4µs making 2 calls to DBIx::Class::Storage::DBI::select, avg 2µs/call
129 }
130
13132457123s goto $orig;
# spent 80.4s making 845 calls to DBIx::Class::Storage::DBI::update, avg 95.2ms/call # spent 36.2s making 449 calls to DBIx::Class::Storage::DBI::insert, avg 80.6ms/call # spent 3.51s making 2007 calls to DBIx::Class::Storage::DBI::select_single, avg 1.75ms/call # spent 2.15s making 19 calls to DBIx::Class::Storage::DBI::delete, avg 113ms/call # spent 319ms making 4699 calls to DBIx::Class::Storage::DBI::select, avg 68µs/call # spent 266ms making 7002 calls to DBIx::Class::Storage::DBI::get_use_dbms_capability, avg 38µs/call # spent 235ms making 4 calls to DBIx::Class::Storage::DBI::deployment_statements, avg 58.8ms/call # spent 76.9ms making 16827 calls to DBIx::Class::Storage::DBI::sql_maker, avg 5µs/call # spent 59.5ms making 294 calls to DBIx::Class::Storage::DBI::txn_begin, avg 203µs/call # spent 18.3ms making 4 calls to DBIx::Class::Storage::DBI::_server_info, avg 4.56ms/call # spent 18.0ms making 4 calls to DBIx::Class::Storage::DBI::_get_server_version, avg 4.49ms/call # spent 10.8ms making 1 call to DBIx::Class::Storage::DBI::build_datetime_parser # spent 10.8ms making 2 calls to DBIx::Class::Storage::DBI::datetime_parser_type, avg 5.38ms/call # spent 2.82ms making 296 calls to DBIx::Class::Storage::DBI::get_dbms_capability, avg 10µs/call # spent 100µs making 4 calls to DBIx::Class::Storage::DBI::sqlt_type, avg 25µs/call
13217114µs1724µs };
# spent 24µs making 17 calls to Sub::Name::subname, avg 1µs/call
133}
134
135=head1 NAME
136
137DBIx::Class::Storage::DBI - DBI storage handler
138
139=head1 SYNOPSIS
140
141 my $schema = MySchema->connect('dbi:SQLite:my.db');
142
143 $schema->storage->debug(1);
144
145 my @stuff = $schema->storage->dbh_do(
146 sub {
147 my ($storage, $dbh, @args) = @_;
148 $dbh->do("DROP TABLE authors");
149 },
150 @column_list
151 );
152
153 $schema->resultset('Book')->search({
154 written_on => $schema->storage->datetime_parser->format_datetime(DateTime->now)
155 });
156
157=head1 DESCRIPTION
158
159This class represents the connection to an RDBMS via L<DBI>. See
160L<DBIx::Class::Storage> for general information. This pod only
161documents DBI-specific methods and behaviors.
162
163=head1 METHODS
164
165=cut
166
167
# spent 709µs (111+598) within DBIx::Class::Storage::DBI::new which was called 6 times, avg 118µs/call: # 6 times (111µs+598µs) by DBIx::Class::Schema::connection at line 835 of DBIx/Class/Schema.pm, avg 118µs/call
sub new {
1684268µs649µs my $new = shift->next::method(@_);
# spent 49µs making 6 calls to next::method, avg 8µs/call
169
170294µs $new->_sql_maker_opts({});
# spent 94µs making 2 calls to DBIx::Class::Storage::DBI::_sql_maker_opts, avg 47µs/call
171290µs $new->_dbh_details({});
# spent 90µs making 2 calls to DBIx::Class::Storage::DBI::_dbh_details, avg 45µs/call
172 $new->{_in_do_block} = 0;
173 $new->{_dbh_gen} = 0;
174
175 # read below to see what this does
176659µs $new->_arm_global_destructor;
# spent 59µs making 6 calls to DBIx::Class::Storage::DBI::_arm_global_destructor, avg 10µs/call
177
178 $new;
179}
180
181# This is hack to work around perl shooting stuff in random
182# order on exit(). If we do not walk the remaining storage
183# objects in an END block, there is a *small but real* chance
184# of a fork()ed child to kill the parent's shared DBI handle,
185# *before perl reaches the DESTROY in this package*
186# Yes, it is ugly and effective.
187# Additionally this registry is used by the CLONE method to
188# make sure no handles are shared between threads
189{
19022µs my %seek_and_destroy;
191
192
# spent 59µs (45+14) within DBIx::Class::Storage::DBI::_arm_global_destructor which was called 6 times, avg 10µs/call: # 6 times (45µs+14µs) by DBIx::Class::Storage::DBI::new at line 176, avg 10µs/call
sub _arm_global_destructor {
1932464µs my $self = shift;
19469µs my $key = refaddr ($self);
# spent 9µs making 6 calls to Scalar::Util::refaddr, avg 1µs/call
195 $seek_and_destroy{$key} = $self;
19665µs weaken ($seek_and_destroy{$key});
# spent 5µs making 6 calls to Scalar::Util::weaken, avg 883ns/call
197 }
198
199
# spent 106µs (66+39) within DBIx::Class::Storage::DBI::END which was called: # once (66µs+39µs) by main::RUNTIME at line 0 of xt/tapper-mcp-scheduler-with-db-longrun.t
END {
200350µs local $?; # just in case the DBI destructor changes it somehow
201
202 # destroy just the object if not native to this process/thread
203639µs $_->_verify_pid for (grep
# spent 39µs making 6 calls to DBIx::Class::Storage::DBI::_verify_pid, avg 7µs/call
204 { defined $_ }
205 values %seek_and_destroy
206 );
207 }
208
209 sub CLONE {
210 # As per DBI's recommendation, DBIC disconnects all handles as
211 # soon as possible (DBIC will reconnect only on demand from within
212 # the thread)
213 for (values %seek_and_destroy) {
214 next unless $_;
215 $_->{_dbh_gen}++; # so that existing cursors will drop as well
216 $_->_dbh(undef);
217
218 $_->transaction_depth(0);
219 $_->savepoints([]);
220 }
221 }
222}
223
224sub DESTROY {
225 my $self = shift;
226
227 # some databases spew warnings on implicit disconnect
228 local $SIG{__WARN__} = sub {};
229 $self->_dbh(undef);
230
231 # this op is necessary, since the very last perl runtime statement
232 # triggers a global destruction shootout, and the $SIG localization
233 # may very well be destroyed before perl actually gets to do the
234 # $dbh undef
235 1;
236}
237
238# handle pid changes correctly - do not destroy parent's connection
239
# spent 80.0ms (79.8+158µs) within DBIx::Class::Storage::DBI::_verify_pid which was called 22890 times, avg 3µs/call: # 22588 times (79.0ms+158µs) by DBIx::Class::Storage::DBI::_get_dbh at line 936, avg 4µs/call # 294 times (725µs+0s) by DBIx::Class::Storage::DBI::txn_commit at line 1346, avg 2µs/call # 6 times (39µs+0s) by DBIx::Class::Storage::DBI::END at line 203, avg 7µs/call # 2 times (9µs+0s) by DBIx::Class::Storage::DBI::_seems_connected at line 888, avg 5µs/call
sub _verify_pid {
24091560114ms my $self = shift;
241
2422158µs my $pid = $self->_conn_pid;
# spent 157µs making 1 call to DBIx::Class::Storage::DBI::_conn_pid # spent 700ns making 1 call to DBIx::Class::Storage::DBI::SQLite::_conn_pid
243 if( defined $pid and $pid != $$ and my $dbh = $self->_dbh ) {
244 $dbh->{InactiveDestroy} = 1;
245 $self->{_dbh_gen}++;
246 $self->_dbh(undef);
247 $self->transaction_depth(0);
248 $self->savepoints([]);
249 }
250
251 return;
252}
253
254=head2 connect_info
255
256This method is normally called by L<DBIx::Class::Schema/connection>, which
257encapsulates its argument list in an arrayref before passing them here.
258
259The argument list may contain:
260
261=over
262
263=item *
264
265The same 4-element argument set one would normally pass to
266L<DBI/connect>, optionally followed by
267L<extra attributes|/DBIx::Class specific connection attributes>
268recognized by DBIx::Class:
269
270 $connect_info_args = [ $dsn, $user, $password, \%dbi_attributes?, \%extra_attributes? ];
271
272=item *
273
274A single code reference which returns a connected
275L<DBI database handle|DBI/connect> optionally followed by
276L<extra attributes|/DBIx::Class specific connection attributes> recognized
277by DBIx::Class:
278
279 $connect_info_args = [ sub { DBI->connect (...) }, \%extra_attributes? ];
280
281=item *
282
283A single hashref with all the attributes and the dsn/user/password
284mixed together:
285
286 $connect_info_args = [{
287 dsn => $dsn,
288 user => $user,
289 password => $pass,
290 %dbi_attributes,
291 %extra_attributes,
292 }];
293
294 $connect_info_args = [{
295 dbh_maker => sub { DBI->connect (...) },
296 %dbi_attributes,
297 %extra_attributes,
298 }];
299
300This is particularly useful for L<Catalyst> based applications, allowing the
301following config (L<Config::General> style):
302
303 <Model::DB>
304 schema_class App::DB
305 <connect_info>
306 dsn dbi:mysql:database=test
307 user testuser
308 password TestPass
309 AutoCommit 1
310 </connect_info>
311 </Model::DB>
312
313The C<dsn>/C<user>/C<password> combination can be substituted by the
314C<dbh_maker> key whose value is a coderef that returns a connected
315L<DBI database handle|DBI/connect>
316
317=back
318
319Please note that the L<DBI> docs recommend that you always explicitly
320set C<AutoCommit> to either I<0> or I<1>. L<DBIx::Class> further
321recommends that it be set to I<1>, and that you perform transactions
322via our L<DBIx::Class::Schema/txn_do> method. L<DBIx::Class> will set it
323to I<1> if you do not do explicitly set it to zero. This is the default
324for most DBDs. See L</DBIx::Class and AutoCommit> for details.
325
326=head3 DBIx::Class specific connection attributes
327
328In addition to the standard L<DBI|DBI/ATTRIBUTES_COMMON_TO_ALL_HANDLES>
329L<connection|DBI/Database_Handle_Attributes> attributes, DBIx::Class recognizes
330the following connection options. These options can be mixed in with your other
331L<DBI> connection attributes, or placed in a separate hashref
332(C<\%extra_attributes>) as shown above.
333
334Every time C<connect_info> is invoked, any previous settings for
335these options will be cleared before setting the new ones, regardless of
336whether any options are specified in the new C<connect_info>.
337
338
339=over
340
341=item on_connect_do
342
343Specifies things to do immediately after connecting or re-connecting to
344the database. Its value may contain:
345
346=over
347
348=item a scalar
349
350This contains one SQL statement to execute.
351
352=item an array reference
353
354This contains SQL statements to execute in order. Each element contains
355a string or a code reference that returns a string.
356
357=item a code reference
358
359This contains some code to execute. Unlike code references within an
360array reference, its return value is ignored.
361
362=back
363
364=item on_disconnect_do
365
366Takes arguments in the same form as L</on_connect_do> and executes them
367immediately before disconnecting from the database.
368
369Note, this only runs if you explicitly call L</disconnect> on the
370storage object.
371
372=item on_connect_call
373
374A more generalized form of L</on_connect_do> that calls the specified
375C<connect_call_METHOD> methods in your storage driver.
376
377 on_connect_do => 'select 1'
378
379is equivalent to:
380
381 on_connect_call => [ [ do_sql => 'select 1' ] ]
382
383Its values may contain:
384
385=over
386
387=item a scalar
388
389Will call the C<connect_call_METHOD> method.
390
391=item a code reference
392
393Will execute C<< $code->($storage) >>
394
395=item an array reference
396
397Each value can be a method name or code reference.
398
399=item an array of arrays
400
401For each array, the first item is taken to be the C<connect_call_> method name
402or code reference, and the rest are parameters to it.
403
404=back
405
406Some predefined storage methods you may use:
407
408=over
409
410=item do_sql
411
412Executes a SQL string or a code reference that returns a SQL string. This is
413what L</on_connect_do> and L</on_disconnect_do> use.
414
415It can take:
416
417=over
418
419=item a scalar
420
421Will execute the scalar as SQL.
422
423=item an arrayref
424
425Taken to be arguments to L<DBI/do>, the SQL string optionally followed by the
426attributes hashref and bind values.
427
428=item a code reference
429
430Will execute C<< $code->($storage) >> and execute the return array refs as
431above.
432
433=back
434
435=item datetime_setup
436
437Execute any statements necessary to initialize the database session to return
438and accept datetime/timestamp values used with
439L<DBIx::Class::InflateColumn::DateTime>.
440
441Only necessary for some databases, see your specific storage driver for
442implementation details.
443
444=back
445
446=item on_disconnect_call
447
448Takes arguments in the same form as L</on_connect_call> and executes them
449immediately before disconnecting from the database.
450
451Calls the C<disconnect_call_METHOD> methods as opposed to the
452C<connect_call_METHOD> methods called by L</on_connect_call>.
453
454Note, this only runs if you explicitly call L</disconnect> on the
455storage object.
456
457=item disable_sth_caching
458
459If set to a true value, this option will disable the caching of
460statement handles via L<DBI/prepare_cached>.
461
462=item limit_dialect
463
464Sets a specific SQL::Abstract::Limit-style limit dialect, overriding the
465default L</sql_limit_dialect> setting of the storage (if any). For a list
466of available limit dialects see L<DBIx::Class::SQLMaker::LimitDialects>.
467
468=item quote_names
469
470When true automatically sets L</quote_char> and L</name_sep> to the characters
471appropriate for your particular RDBMS. This option is preferred over specifying
472L</quote_char> directly.
473
474=item quote_char
475
476Specifies what characters to use to quote table and column names.
477
478C<quote_char> expects either a single character, in which case is it
479is placed on either side of the table/column name, or an arrayref of length
4802 in which case the table/column name is placed between the elements.
481
482For example under MySQL you should use C<< quote_char => '`' >>, and for
483SQL Server you should use C<< quote_char => [qw/[ ]/] >>.
484
485=item name_sep
486
487This parameter is only useful in conjunction with C<quote_char>, and is used to
488specify the character that separates elements (schemas, tables, columns) from
489each other. If unspecified it defaults to the most commonly used C<.>.
490
491=item unsafe
492
493This Storage driver normally installs its own C<HandleError>, sets
494C<RaiseError> and C<ShowErrorStatement> on, and sets C<PrintError> off on
495all database handles, including those supplied by a coderef. It does this
496so that it can have consistent and useful error behavior.
497
498If you set this option to a true value, Storage will not do its usual
499modifications to the database handle's attributes, and instead relies on
500the settings in your connect_info DBI options (or the values you set in
501your connection coderef, in the case that you are connecting via coderef).
502
503Note that your custom settings can cause Storage to malfunction,
504especially if you set a C<HandleError> handler that suppresses exceptions
505and/or disable C<RaiseError>.
506
507=item auto_savepoint
508
509If this option is true, L<DBIx::Class> will use savepoints when nesting
510transactions, making it possible to recover from failure in the inner
511transaction without having to abort all outer transactions.
512
513=item cursor_class
514
515Use this argument to supply a cursor class other than the default
516L<DBIx::Class::Storage::DBI::Cursor>.
517
518=back
519
520Some real-life examples of arguments to L</connect_info> and
521L<DBIx::Class::Schema/connect>
522
523 # Simple SQLite connection
524 ->connect_info([ 'dbi:SQLite:./foo.db' ]);
525
526 # Connect via subref
527 ->connect_info([ sub { DBI->connect(...) } ]);
528
529 # Connect via subref in hashref
530 ->connect_info([{
531 dbh_maker => sub { DBI->connect(...) },
532 on_connect_do => 'alter session ...',
533 }]);
534
535 # A bit more complicated
536 ->connect_info(
537 [
538 'dbi:Pg:dbname=foo',
539 'postgres',
540 'my_pg_password',
541 { AutoCommit => 1 },
542 { quote_char => q{"} },
543 ]
544 );
545
546 # Equivalent to the previous example
547 ->connect_info(
548 [
549 'dbi:Pg:dbname=foo',
550 'postgres',
551 'my_pg_password',
552 { AutoCommit => 1, quote_char => q{"}, name_sep => q{.} },
553 ]
554 );
555
556 # Same, but with hashref as argument
557 # See parse_connect_info for explanation
558 ->connect_info(
559 [{
560 dsn => 'dbi:Pg:dbname=foo',
561 user => 'postgres',
562 password => 'my_pg_password',
563 AutoCommit => 1,
564 quote_char => q{"},
565 name_sep => q{.},
566 }]
567 );
568
569 # Subref + DBIx::Class-specific connection options
570 ->connect_info(
571 [
572 sub { DBI->connect(...) },
573 {
574 quote_char => q{`},
575 name_sep => q{@},
576 on_connect_do => ['SET search_path TO myschema,otherschema,public'],
577 disable_sth_caching => 1,
578 },
579 ]
580 );
581
- -
584=cut
585
586
# spent 752µs (225+528) within DBIx::Class::Storage::DBI::connect_info which was called 9 times, avg 84µs/call: # 6 times (217µs+527µs) by DBIx::Class::Schema::connection at line 836 of DBIx/Class/Schema.pm, avg 124µs/call # 3 times (7µs+700ns) by DBIx::Class::Schema::Versioned::_on_connect at line 592 of DBIx/Class/Schema/Versioned.pm, avg 3µs/call
sub connect_info {
587102183µs my ($self, $info) = @_;
588
5891700ns return $self->_connect_info if !$info;
# spent 700ns making 1 call to DBIx::Class::Storage::DBI::_connect_info
590
5912109µs $self->_connect_info($info); # copy for _connect_info
# spent 109µs making 2 calls to DBIx::Class::Storage::DBI::_connect_info, avg 54µs/call
592
5936103µs $info = $self->_normalize_connect_info($info)
# spent 103µs making 6 calls to DBIx::Class::Storage::DBI::_normalize_connect_info, avg 17µs/call
594 if ref $info eq 'ARRAY';
595
596 for my $storage_opt (keys %{ $info->{storage_options} }) {
597 my $value = $info->{storage_options}{$storage_opt};
598
599 $self->$storage_opt($value);
600 }
601
602 # Kill sql_maker/_sql_maker_opts, so we get a fresh one with only
603 # the new set of options
604292µs $self->_sql_maker(undef);
# spent 92µs making 2 calls to DBIx::Class::Storage::DBI::_sql_maker, avg 46µs/call
60511µs $self->_sql_maker_opts({});
# spent 1µs making 1 call to DBIx::Class::Storage::DBI::_sql_maker_opts
606
607 for my $sql_maker_opt (keys %{ $info->{sql_maker_options} }) {
608 my $value = $info->{sql_maker_options}{$sql_maker_opt};
609
610 $self->_sql_maker_opts->{$sql_maker_opt} = $value;
611 }
612
613 my %attrs = (
614 %{ $self->_default_dbi_connect_attributes || {} },
615618µs %{ $info->{attributes} || {} },
# spent 18µs making 6 calls to DBIx::Class::Storage::DBI::_default_dbi_connect_attributes, avg 3µs/call
616 );
617
618 my @args = @{ $info->{arguments} };
619
620 if (keys %attrs and ref $args[0] ne 'CODE') {
621 carp
622 'You provided explicit AutoCommit => 0 in your connection_info. '
623 . 'This is almost universally a bad idea (see the footnotes of '
624 . 'DBIx::Class::Storage::DBI for more info). If you still want to '
625 . 'do this you can set $ENV{DBIC_UNSAFE_AUTOCOMMIT_OK} to disable '
626 . 'this warning.'
627 if ! $attrs{AutoCommit} and ! $ENV{DBIC_UNSAFE_AUTOCOMMIT_OK};
628
629 push @args, \%attrs if keys %attrs;
630 }
6312104µs $self->_dbi_connect_info(\@args);
# spent 104µs making 2 calls to DBIx::Class::Storage::DBI::_dbi_connect_info, avg 52µs/call
632
633 # FIXME - dirty:
634 # save attributes them in a separate accessor so they are always
635 # introspectable, even in case of a CODE $dbhmaker
636298µs $self->_dbic_connect_attributes (\%attrs);
# spent 98µs making 2 calls to DBIx::Class::Storage::DBI::_dbic_connect_attributes, avg 49µs/call
637
6381700ns return $self->_connect_info;
# spent 700ns making 1 call to DBIx::Class::Storage::DBI::_connect_info
639}
640
641
# spent 103µs within DBIx::Class::Storage::DBI::_normalize_connect_info which was called 6 times, avg 17µs/call: # 6 times (103µs+0s) by DBIx::Class::Storage::DBI::connect_info at line 593, avg 17µs/call
sub _normalize_connect_info {
64284112µs my ($self, $info_arg) = @_;
643 my %info;
644
645 my @args = @$info_arg; # take a shallow copy for further mutilation
646
647 # combine/pre-parse arguments depending on invocation style
648
649 my %attrs;
650 if (ref $args[0] eq 'CODE') { # coderef with optional \%extra_attributes
651 %attrs = %{ $args[1] || {} };
652 @args = $args[0];
653 }
654 elsif (ref $args[0] eq 'HASH') { # single hashref (i.e. Catalyst config)
655 %attrs = %{$args[0]};
656 @args = ();
657 if (my $code = delete $attrs{dbh_maker}) {
658 @args = $code;
659
660 my @ignored = grep { delete $attrs{$_} } (qw/dsn user password/);
661 if (@ignored) {
662 carp sprintf (
663 'Attribute(s) %s in connect_info were ignored, as they can not be applied '
664 . "to the result of 'dbh_maker'",
665
666 join (', ', map { "'$_'" } (@ignored) ),
667 );
668 }
669 }
670 else {
671 @args = delete @attrs{qw/dsn user password/};
672 }
673 }
674 else { # otherwise assume dsn/user/password + \%attrs + \%extra_attrs
675 %attrs = (
676 % { $args[3] || {} },
677 % { $args[4] || {} },
678 );
679 @args = @args[0,1,2];
680 }
681
682 $info{arguments} = \@args;
683
684 my @storage_opts = grep exists $attrs{$_},
685 @storage_options, 'cursor_class';
686
687 @{ $info{storage_options} }{@storage_opts} =
688 delete @attrs{@storage_opts} if @storage_opts;
689
690 my @sql_maker_opts = grep exists $attrs{$_},
691 qw/limit_dialect quote_char name_sep quote_names/;
692
693 @{ $info{sql_maker_options} }{@sql_maker_opts} =
694 delete @attrs{@sql_maker_opts} if @sql_maker_opts;
695
696 $info{attributes} = \%attrs if %attrs;
697
698 return \%info;
699}
700
701
# spent 18µs within DBIx::Class::Storage::DBI::_default_dbi_connect_attributes which was called 6 times, avg 3µs/call: # 6 times (18µs+0s) by DBIx::Class::Storage::DBI::connect_info at line 615, avg 3µs/call
sub _default_dbi_connect_attributes () {
702 +{
703625µs AutoCommit => 1,
704 PrintError => 0,
705 RaiseError => 1,
706 ShowErrorStatement => 1,
707 };
708}
709
710=head2 on_connect_do
711
712This method is deprecated in favour of setting via L</connect_info>.
713
714=cut
715
716=head2 on_disconnect_do
717
718This method is deprecated in favour of setting via L</connect_info>.
719
720=cut
721
722
# spent 139µs (43+95) within DBIx::Class::Storage::DBI::_parse_connect_do which was called 6 times, avg 23µs/call: # 6 times (43µs+95µs) by DBIx::Class::Storage::DBI::_run_connection_actions at line 1026, avg 23µs/call
sub _parse_connect_do {
7231847µs my ($self, $type) = @_;
724
725295µs my $val = $self->$type;
# spent 94µs making 1 call to DBIx::Class::Storage::DBI::on_connect_do # spent 900ns making 1 call to DBIx::Class::Storage::DBI::SQLite::on_connect_do
726 return () if not defined $val;
727
728 my @res;
729
730 if (not ref($val)) {
731 push @res, [ 'do_sql', $val ];
732 } elsif (ref($val) eq 'CODE') {
733 push @res, $val;
734 } elsif (ref($val) eq 'ARRAY') {
735 push @res, map { [ 'do_sql', $_ ] } @$val;
736 } else {
737 $self->throw_exception("Invalid type for $type: ".ref($val));
738 }
739
740 return \@res;
741}
742
743=head2 dbh_do
744
745Arguments: ($subref | $method_name), @extra_coderef_args?
746
747Execute the given $subref or $method_name using the new exception-based
748connection management.
749
750The first two arguments will be the storage object that C<dbh_do> was called
751on and a database handle to use. Any additional arguments will be passed
752verbatim to the called subref as arguments 2 and onwards.
753
754Using this (instead of $self->_dbh or $self->dbh) ensures correct
755exception handling and reconnection (or failover in future subclasses).
756
757Your subref should have no side-effects outside of the database, as
758there is the potential for your subref to be partially double-executed
759if the database connection was stale/dysfunctional.
760
761Example:
762
763 my @stuff = $schema->storage->dbh_do(
764 sub {
765 my ($storage, $dbh, @cols) = @_;
766 my $cols = join(q{, }, @cols);
767 $dbh->selectrow_array("SELECT $cols FROM foo");
768 },
769 @column_list
770 );
771
772=cut
773
774
# spent 132s (376ms+132) within DBIx::Class::Storage::DBI::dbh_do which was called 22286 times, avg 5.94ms/call: # 8019 times (161ms+117s) by DBIx::Class::Storage::DBI::_execute at line 1558, avg 14.6ms/call # 8019 times (70.9ms+-70.9ms) by DBIx::Class::Storage::DBI::_sth at line 2281, avg 0s/call # 4273 times (92.6ms+4.77s) by DBIx::Class::Storage::DBI::Cursor::next at line 108 of DBIx/Class/Storage/DBI/Cursor.pm, avg 1.14ms/call # 1610 times (39.5ms+2.28s) by DBIx::Class::Storage::DBI::Cursor::all at line 143 of DBIx/Class/Storage/DBI/Cursor.pm, avg 1.44ms/call # 294 times (7.85ms+27.4ms) by DBIx::Class::Storage::DBI::_exec_txn_begin at line 1339, avg 120µs/call # 71 times (3.92ms+7.94s) by DBIx::Class::Storage::DBI::__ANON__[/2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/site_perl/5.12.3/DBIx/Class/Storage/DBI.pm:2763] at line 2762, avg 112ms/call
sub dbh_do {
775116966342ms my $self = shift;
776 my $code = shift;
777
77822286232ms my $dbh = $self->_get_dbh;
# spent 232ms making 22286 calls to DBIx::Class::Storage::DBI::_get_dbh, avg 10µs/call
779
780130121.48s return $self->$code($dbh, @_)
# spent 1.01s making 4993 calls to DBIx::Class::Storage::DBI::_dbh_execute, avg 202µs/call # spent 472ms making 8019 calls to DBIx::Class::Storage::DBI::_dbh_sth, avg 59µs/call
781 if ( $self->{_in_do_block} || $self->{transaction_depth} );
782
783 local $self->{_in_do_block} = 1;
784
785 # take a ref instead of a copy, to preserve coderef @_ aliasing semantics
786 my $args = \@_;
787
788
# spent 132s (65.1ms+131) within DBIx::Class::Storage::DBI::__ANON__[/2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/site_perl/5.12.3/DBIx/Class/Storage/DBI.pm:790] which was called 9274 times, avg 14.2ms/call: # 8889 times (61.8ms+121s) by Try::Tiny::try at line 71 of Try/Tiny.pm, avg 13.7ms/call # 385 times (3.31ms+10.1s) by Try::Tiny::try at line 76 of Try/Tiny.pm, avg 26.2ms/call
try {
789927468.1ms9274131s $self->$code ($dbh, @$args);
# spent 117s making 3026 calls to DBIx::Class::Storage::DBI::_dbh_execute, avg 38.6ms/call # spent 7.93s making 71 calls to DBIx::Class::Storage::DBI::__ANON__[DBIx/Class/Storage/DBI.pm:2762], avg 112ms/call # spent 4.59s making 4273 calls to DBIx::Class::Storage::DBI::Cursor::_dbh_next, avg 1.07ms/call # spent 2.21s making 1610 calls to DBIx::Class::Storage::DBI::Cursor::_dbh_all, avg 1.37ms/call # spent 14.3ms making 294 calls to DBIx::Class::Storage::DBI::__ANON__[DBIx/Class/Storage/DBI.pm:1339], avg 49µs/call
790
# spent 357µs (24+333) within DBIx::Class::Storage::DBI::__ANON__[/2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/site_perl/5.12.3/DBIx/Class/Storage/DBI.pm:800] which was called 2 times, avg 178µs/call: # 2 times (24µs+333µs) by Try::Tiny::try at line 100 of Try/Tiny.pm, avg 178µs/call
} catch {
791211µs6335µs $self->throw_exception($_) if $self->connected;
# spent 212µs making 2 calls to DBIx::Class::Storage::DBI::connected, avg 106µs/call # spent 121µs making 2 calls to DBIx::Class::Storage::throw_exception, avg 61µs/call # spent 2µs making 2 calls to DBI::common::STORE, avg 1µs/call
792
793 # We were not connected - reconnect and retry, but let any
794 # exception fall right through this time
795 carp "Retrying dbh_do($code) after catching disconnected exception: $_"
796 if $ENV{DBIC_STORAGE_RETRY_DEBUG};
797
798 $self->_populate_dbh;
799 $self->$code($self->_dbh, @$args);
80018548124s };
# spent 132s making 9274 calls to Try::Tiny::try, avg 14.2ms/call, recursion: max depth 1, sum of overlapping time 7.95s # spent 63.3ms making 9274 calls to Try::Tiny::catch, avg 7µs/call
801}
802
803sub txn_do {
804 # connects or reconnects on pid change, necessary to grab correct txn_depth
805 $_[0]->_get_dbh;
806 local $_[0]->{_in_do_block} = 1;
807 shift->next::method(@_);
808}
809
810=head2 disconnect
811
812Our C<disconnect> method also performs a rollback first if the
813database is not in C<AutoCommit> mode.
814
815=cut
816
817sub disconnect {
818 my ($self) = @_;
819
820 if( $self->_dbh ) {
821 my @actions;
822
823 push @actions, ( $self->on_disconnect_call || () );
824 push @actions, $self->_parse_connect_do ('on_disconnect_do');
825
826 $self->_do_connection_actions(disconnect_call_ => $_) for @actions;
827
828 # stops the "implicit rollback on disconnect" warning
829 $self->_exec_txn_rollback unless $self->_dbh_autocommit;
830
831 %{ $self->_dbh->{CachedKids} } = ();
832 $self->_dbh->disconnect;
833 $self->_dbh(undef);
834 $self->{_dbh_gen}++;
835 }
836}
837
838=head2 with_deferred_fk_checks
839
840=over 4
841
842=item Arguments: C<$coderef>
843
844=item Return Value: The return value of $coderef
845
846=back
847
848Storage specific method to run the code ref with FK checks deferred or
849in MySQL's case disabled entirely.
850
851=cut
852
853# Storage subclasses should override this
854sub with_deferred_fk_checks {
855 my ($self, $sub) = @_;
856 $sub->();
857}
858
859=head2 connected
860
861=over
862
863=item Arguments: none
864
865=item Return Value: 1|0
866
867=back
868
869Verifies that the current database handle is active and ready to execute
870an SQL statement (e.g. the connection did not get stale, server is still
871answering, etc.) This method is used internally by L</dbh>.
872
873=cut
874
875
# spent 212µs (68+144) within DBIx::Class::Storage::DBI::connected which was called 2 times, avg 106µs/call: # 2 times (68µs+144µs) by DBIx::Class::Storage::DBI::__ANON__[/2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/site_perl/5.12.3/DBIx/Class/Storage/DBI.pm:800] at line 791, avg 106µs/call
sub connected {
876879µs my $self = shift;
877243µs return 0 unless $self->_seems_connected;
# spent 43µs making 2 calls to DBIx::Class::Storage::DBI::_seems_connected, avg 21µs/call
878
879 #be on the safe side
880510µs local $self->_dbh->{RaiseError} = 1;
# spent 6µs making 2 calls to DBI::common::STORE, avg 3µs/call # spent 3µs making 2 calls to DBI::common::FETCH, avg 2µs/call # spent 600ns making 1 call to DBIx::Class::Storage::DBI::_dbh
881
882289µs return $self->_ping;
# spent 89µs making 2 calls to DBIx::Class::Storage::DBI::_ping, avg 45µs/call
883}
884
885
# spent 43µs (25+18) within DBIx::Class::Storage::DBI::_seems_connected which was called 2 times, avg 21µs/call: # 2 times (25µs+18µs) by DBIx::Class::Storage::DBI::connected at line 877, avg 21µs/call
sub _seems_connected {
886834µs my $self = shift;
887
88829µs $self->_verify_pid;
# spent 9µs making 2 calls to DBIx::Class::Storage::DBI::_verify_pid, avg 5µs/call
889
89012µs my $dbh = $self->_dbh
# spent 2µs making 1 call to DBIx::Class::Storage::DBI::_dbh
891 or return 0;
892
89327µs return $dbh->FETCH('Active');
# spent 7µs making 2 calls to DBI::common::FETCH, avg 4µs/call
894}
895
896
# spent 89µs (15+74) within DBIx::Class::Storage::DBI::_ping which was called 2 times, avg 45µs/call: # 2 times (15µs+74µs) by DBIx::Class::Storage::DBI::connected at line 882, avg 45µs/call
sub _ping {
897617µs my $self = shift;
898
8991400ns my $dbh = $self->_dbh or return 0;
# spent 400ns making 1 call to DBIx::Class::Storage::DBI::_dbh
900
901113µs4133µs return $dbh->ping;
# spent 74µs making 2 calls to DBI::db::ping, avg 37µs/call # spent 60µs making 2 calls to DBD::_::db::ping, avg 30µs/call
902}
903
904sub ensure_connected {
905 my ($self) = @_;
906
907 unless ($self->connected) {
908 $self->_populate_dbh;
909 }
910}
911
912=head2 dbh
913
914Returns a C<$dbh> - a data base handle of class L<DBI>. The returned handle
915is guaranteed to be healthy by implicitly calling L</connected>, and if
916necessary performing a reconnection before returning. Keep in mind that this
917is very B<expensive> on some database engines. Consider using L</dbh_do>
918instead.
919
920=cut
921
922sub dbh {
923 my ($self) = @_;
924
925 if (not $self->_dbh) {
926 $self->_populate_dbh;
927 } else {
928 $self->ensure_connected;
929 }
930 return $self->_dbh;
931}
932
933# this is the internal "get dbh or connect (don't check)" method
934
# spent 254ms (154+99.9) within DBIx::Class::Storage::DBI::_get_dbh which was called 22588 times, avg 11µs/call: # 22286 times (151ms+80.6ms) by DBIx::Class::Storage::DBI::dbh_do at line 778, avg 10µs/call # 294 times (3.08ms+1.61ms) by DBIx::Class::Storage::DBI::txn_begin at line 1322, avg 16µs/call # 4 times (42µs+17.7ms) by DBIx::Class::Storage::DBI::__ANON__[/2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/site_perl/5.12.3/DBIx/Class/Storage/DBI.pm:1116] at line 1116, avg 4.44ms/call # 4 times (17µs+14µs) by DBIx::Class::Storage::DBI::sqlt_type at line 2445, avg 8µs/call
sub _get_dbh {
93590352151ms my $self = shift;
9362258879.2ms $self->_verify_pid;
# spent 79.2ms making 22588 calls to DBIx::Class::Storage::DBI::_verify_pid, avg 4µs/call
937720.7ms $self->_populate_dbh unless $self->_dbh;
# spent 20.7ms making 6 calls to DBIx::Class::Storage::DBI::_populate_dbh, avg 3.45ms/call # spent 600ns making 1 call to DBIx::Class::Storage::DBI::_dbh
9381800ns return $self->_dbh;
# spent 800ns making 1 call to DBIx::Class::Storage::DBI::_dbh
939}
940
941
# spent 133ms (118+14.7) within DBIx::Class::Storage::DBI::sql_maker which was called 33656 times, avg 4µs/call: # 16827 times (62.6ms+14.4ms) by DBIx::Class::Storage::DBI::_gen_sql_bind or DBIx::Class::Storage::DBI::_select_args or DBIx::Class::Storage::DBIHacks::_extract_order_criteria or DBIx::Class::Storage::DBIHacks::_resolve_aliastypes_from_select_args at line 131, avg 5µs/call # 8019 times (20.5ms+0s) by DBIx::Class::Storage::DBI::_gen_sql_bind at line 1428, avg 3µs/call # 6706 times (21.6ms+0s) by DBIx::Class::Storage::DBI::_select_args at line 2108, avg 3µs/call # 1955 times (12.9ms+366µs) by DBIx::Class::Storage::DBIHacks::_extract_order_criteria at line 673 of DBIx/Class/Storage/DBIHacks.pm, avg 7µs/call # 147 times (305µs+0s) by DBIx::Class::Storage::DBIHacks::_resolve_aliastypes_from_select_args at line 297 of DBIx/Class/Storage/DBIHacks.pm, avg 2µs/call # 2 times (13µs+0s) by DBIx::Class::Storage::DBIHacks::_extract_order_criteria at line 128, avg 7µs/call
sub sql_maker {
9425051190.1ms my ($self) = @_;
94313µs unless ($self->_sql_maker) {
# spent 3µs making 1 call to DBIx::Class::Storage::DBI::_sql_maker
944513.6ms my $sql_maker_class = $self->sql_maker_class;
# spent 13.6ms making 5 calls to DBIx::Class::Storage::DBI::sql_maker_class, avg 2.72ms/call
945
94612µs my %opts = %{$self->_sql_maker_opts||{}};
# spent 2µs making 1 call to DBIx::Class::Storage::DBI::_sql_maker_opts
947 my $dialect =
948 $opts{limit_dialect}
949 ||
950 $self->sql_limit_dialect
951 ||
9525123µs do {
# spent 123µs making 5 calls to DBIx::Class::Storage::DBI::sql_limit_dialect, avg 25µs/call
953 my $s_class = (ref $self) || $self;
954 carp (
955 "Your storage class ($s_class) does not set sql_limit_dialect and you "
956 . 'have not supplied an explicit limit_dialect in your connection_info. '
957 . 'DBIC will attempt to use the GenericSubQ dialect, which works on most '
958 . 'databases but can be (and often is) painfully slow. '
959 . "Please file an RT ticket against '$s_class' ."
960 );
961
962 'GenericSubQ';
963 }
964 ;
965
966 my ($quote_char, $name_sep);
967
968 if ($opts{quote_names}) {
969 $quote_char = (delete $opts{quote_char}) || $self->sql_quote_char || do {
970 my $s_class = (ref $self) || $self;
971 carp (
972 "You requested 'quote_names' but your storage class ($s_class) does "
973 . 'not explicitly define a default sql_quote_char and you have not '
974 . 'supplied a quote_char as part of your connection_info. DBIC will '
975 .q{default to the ANSI SQL standard quote '"', which works most of }
976 . "the time. Please file an RT ticket against '$s_class'."
977 );
978
979 '"'; # RV
980 };
981
982 $name_sep = (delete $opts{name_sep}) || $self->sql_name_sep;
983 }
984
9856627µs $self->_sql_maker($sql_maker_class->new(
# spent 625µs making 5 calls to DBIx::Class::SQLMaker::new, avg 125µs/call # spent 2µs making 1 call to DBIx::Class::Storage::DBI::_sql_maker
986 bindtype=>'columns',
987 array_datatypes => 1,
988 limit_dialect => $dialect,
989 ($quote_char ? (quote_char => $quote_char) : ()),
990 name_sep => ($name_sep || '.'),
991 %opts,
992 ));
993 }
9941700ns return $self->_sql_maker;
# spent 700ns making 1 call to DBIx::Class::Storage::DBI::_sql_maker
995}
996
997# nothing to do by default
998621µs
# spent 13µs within DBIx::Class::Storage::DBI::_rebless which was called 6 times, avg 2µs/call: # 6 times (13µs+0s) by DBIx::Class::Storage::DBI::_determine_driver at line 1153, avg 2µs/call
sub _rebless {}
999621µs
# spent 9µs within DBIx::Class::Storage::DBI::_init which was called 6 times, avg 2µs/call: # 6 times (9µs+0s) by DBIx::Class::Storage::DBI::_determine_driver at line 1162, avg 2µs/call
sub _init {}
1000
1001
# spent 20.7ms (209µs+20.5) within DBIx::Class::Storage::DBI::_populate_dbh which was called 6 times, avg 3.45ms/call: # 6 times (209µs+20.5ms) by DBIx::Class::Storage::DBI::_get_dbh at line 937, avg 3.45ms/call
sub _populate_dbh {
100254200µs my ($self) = @_;
1003
100411µs my @info = @{$self->_dbi_connect_info || []};
# spent 1µs making 1 call to DBIx::Class::Storage::DBI::_dbi_connect_info
10051800ns $self->_dbh(undef); # in case ->connected failed we might get sent here
# spent 800ns making 1 call to DBIx::Class::Storage::DBI::_dbh
100611µs $self->_dbh_details({}); # reset everything we know
# spent 1µs making 1 call to DBIx::Class::Storage::DBI::_dbh_details
1007
1008720.2ms $self->_dbh($self->_connect(@info));
# spent 20.2ms making 6 calls to DBIx::Class::Storage::DBI::_connect, avg 3.36ms/call # spent 2µs making 1 call to DBIx::Class::Storage::DBI::_dbh
1009
101012µs $self->_conn_pid($$) if $^O ne 'MSWin32'; # on win32 these are in fact threads
# spent 2µs making 1 call to DBIx::Class::Storage::DBI::SQLite::_conn_pid
1011
1012625µs $self->_determine_driver;
# spent 25µs making 6 calls to DBIx::Class::Storage::DBI::_determine_driver, avg 4µs/call
1013
1014 # Always set the transaction depth on connect, since
1015 # there is no transaction in progress by definition
10161600ns $self->{transaction_depth} = $self->_dbh_autocommit ? 0 : 1;
1017
10186326µs $self->_run_connection_actions unless $self->{_in_determine_driver};
# spent 326µs making 6 calls to DBIx::Class::Storage::DBI::_run_connection_actions, avg 54µs/call
1019}
1020
1021
# spent 326µs (81+245) within DBIx::Class::Storage::DBI::_run_connection_actions which was called 6 times, avg 54µs/call: # 6 times (81µs+245µs) by DBIx::Class::Storage::DBI::_populate_dbh at line 1018, avg 54µs/call
sub _run_connection_actions {
10223671µs my $self = shift;
1023 my @actions;
1024
10252106µs push @actions, ( $self->on_connect_call || () );
# spent 104µs making 1 call to DBIx::Class::Storage::DBI::on_connect_call # spent 1µs making 1 call to DBIx::Class::Storage::DBI::SQLite::on_connect_call
10266139µs push @actions, $self->_parse_connect_do ('on_connect_do');
# spent 139µs making 6 calls to DBIx::Class::Storage::DBI::_parse_connect_do, avg 23µs/call
1027
1028 $self->_do_connection_actions(connect_call_ => $_) for @actions;
1029}
1030
- -
1033
# spent 13µs (6+7) within DBIx::Class::Storage::DBI::set_use_dbms_capability which was called: # once (6µs+7µs) by DBIx::Class::Storage::DBI::_use_join_optimizer at line 2 of (eval 1405)[Class/Accessor/Grouped.pm:807]
sub set_use_dbms_capability {
103416µs17µs $_[0]->set_inherited ($_[1], $_[2]);
# spent 7µs making 1 call to Class::Accessor::Grouped::set_inherited
1035}
1036
1037
# spent 288ms (74.5+213) within DBIx::Class::Storage::DBI::get_use_dbms_capability which was called 14004 times, avg 21µs/call: # 7002 times (52.5ms+213ms) by DBIx::Class::Storage::DBI::_use_insert_returning or DBIx::Class::Storage::DBI::_use_join_optimizer at line 131, avg 38µs/call # 6706 times (20.7ms+0s) by DBIx::Class::Storage::DBI::_use_join_optimizer at line 2 of (eval 1405)[Class/Accessor/Grouped.pm:807], avg 3µs/call # 296 times (1.41ms+0s) by DBIx::Class::Storage::DBI::_use_insert_returning at line 2 of (eval 1401)[Class/Accessor/Grouped.pm:807], avg 5µs/call
sub get_use_dbms_capability {
10382159851.6ms my ($self, $capname) = @_;
1039
10407002206ms my $use = $self->get_inherited ($capname);
# spent 206ms making 7002 calls to Class::Accessor::Grouped::get_inherited, avg 29µs/call
1041 return defined $use
1042 ? $use
10435924.22ms : do { $capname =~ s/^_use_/_supports_/; $self->get_dbms_capability ($capname) }
# spent 2.94ms making 296 calls to DBIx::Class::Storage::DBI::CORE:subst, avg 10µs/call # spent 1.28ms making 296 calls to DBIx::Class::Storage::DBI::get_dbms_capability, avg 4µs/call
1044 ;
1045}
1046
1047
# spent 7µs (6+600ns) within DBIx::Class::Storage::DBI::set_dbms_capability which was called: # once (6µs+600ns) by DBIx::Class::Storage::DBI::get_dbms_capability at line 1064
sub set_dbms_capability {
104819µs1600ns $_[0]->_dbh_details->{capability}{$_[1]} = $_[2];
# spent 600ns making 1 call to DBIx::Class::Storage::DBI::_dbh_details
1049}
1050
1051
# spent 4.10ms (4.08+22µs) within DBIx::Class::Storage::DBI::get_dbms_capability which was called 592 times, avg 7µs/call: # 296 times (2.80ms+22µs) by DBIx::Class::Storage::DBI::get_use_dbms_capability at line 131, avg 10µs/call # 296 times (1.28ms+0s) by DBIx::Class::Storage::DBI::get_use_dbms_capability at line 1043, avg 4µs/call
sub get_dbms_capability {
105211873.58ms my ($self, $capname) = @_;
1053
105412µs my $cap = $self->_dbh_details->{capability}{$capname};
# spent 2µs making 1 call to DBIx::Class::Storage::DBI::_dbh_details
1055
1056 unless (defined $cap) {
1057114µs if (my $meth = $self->can ("_determine$capname")) {
# spent 14µs making 1 call to UNIVERSAL::can
1058 $cap = $self->$meth ? 1 : 0;
1059 }
1060 else {
1061 $cap = 0;
1062 }
1063
106417µs $self->set_dbms_capability ($capname, $cap);
# spent 7µs making 1 call to DBIx::Class::Storage::DBI::set_dbms_capability
1065 }
1066
1067 return $cap;
1068}
1069
1070
# spent 18.3ms (174µs+18.1) within DBIx::Class::Storage::DBI::_server_info which was called 8 times, avg 2.28ms/call: # 4 times (155µs+18.1ms) by DBIx::Class::Storage::DBI::SQLite::deployment_statements at line 131, avg 4.56ms/call # 4 times (19µs+700ns) by DBIx::Class::Storage::DBI::SQLite::deployment_statements at line 82 of DBIx/Class/Storage/DBI/SQLite.pm, avg 5µs/call
sub _server_info {
1071100184µs my $self = shift;
1072
1073 my $info;
107411µs unless ($info = $self->_dbh_details->{info}) {
# spent 1µs making 1 call to DBIx::Class::Storage::DBI::_dbh_details
1075
1076 $info = {};
1077
1078419µs818.1ms
# spent 18.0ms (32µs+18.0) within DBIx::Class::Storage::DBI::__ANON__[/2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/site_perl/5.12.3/DBIx/Class/Storage/DBI.pm:1078] which was called 4 times, avg 4.50ms/call: # 4 times (32µs+18.0ms) by Try::Tiny::try at line 71 of Try/Tiny.pm, avg 4.50ms/call
my $server_version = try { $self->_get_server_version };
# spent 18.1ms making 4 calls to Try::Tiny::try, avg 4.52ms/call # spent 11µs making 4 calls to DBIx::Class::Storage::DBI::_get_server_version, avg 3µs/call
1079
1080 if (defined $server_version) {
1081 $info->{dbms_version} = $server_version;
1082
1083421µs my ($numeric_version) = $server_version =~ /^([\d\.]+)/;
# spent 21µs making 4 calls to DBIx::Class::Storage::DBI::CORE:match, avg 5µs/call
1084 my @verparts = split (/\./, $numeric_version);
1085 if (
1086 @verparts
1087 &&
1088 $verparts[0] <= 999
1089 ) {
1090 # consider only up to 3 version parts, iff not more than 3 digits
1091 my @use_parts;
1092 while (@verparts && @use_parts < 3) {
1093 my $p = shift @verparts;
1094 last if $p > 999;
1095 push @use_parts, $p;
1096 }
1097 push @use_parts, 0 while @use_parts < 3;
1098
1099 $info->{normalized_dbms_version} = sprintf "%d.%03d%03d", @use_parts;
1100 }
1101 }
1102
110312µs $self->_dbh_details->{info} = $info;
# spent 2µs making 1 call to DBIx::Class::Storage::DBI::_dbh_details
1104 }
1105
1106 return $info;
1107}
1108
1109
# spent 18.0ms (32µs+18.0) within DBIx::Class::Storage::DBI::_get_server_version which was called 8 times, avg 2.25ms/call: # 4 times (21µs+18.0ms) by DBIx::Class::Storage::DBI::__ANON__[/2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/site_perl/5.12.3/DBIx/Class/Storage/DBI.pm:1078] at line 131, avg 4.49ms/call # 4 times (11µs+0s) by DBIx::Class::Storage::DBI::__ANON__[/2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/site_perl/5.12.3/DBIx/Class/Storage/DBI.pm:1078] at line 1078, avg 3µs/call
sub _get_server_version {
1110421µs418.0ms shift->_dbh_get_info(18);
# spent 18.0ms making 4 calls to DBIx::Class::Storage::DBI::_dbh_get_info, avg 4.49ms/call
1111}
1112
1113
# spent 18.0ms (33µs+17.9) within DBIx::Class::Storage::DBI::_dbh_get_info which was called 4 times, avg 4.49ms/call: # 4 times (33µs+17.9ms) by DBIx::Class::Storage::DBI::_get_server_version at line 1110, avg 4.49ms/call
sub _dbh_get_info {
1114829µs my ($self, $info) = @_;
1115
1116458µs1617.9ms
# spent 17.9ms (35µs+17.8) within DBIx::Class::Storage::DBI::__ANON__[/2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/site_perl/5.12.3/DBIx/Class/Storage/DBI.pm:1116] which was called 4 times, avg 4.47ms/call: # 4 times (35µs+17.8ms) by Try::Tiny::try at line 71 of Try/Tiny.pm, avg 4.47ms/call
return try { $self->_get_dbh->get_info($info) } || undef;
# spent 17.7ms making 4 calls to DBIx::Class::Storage::DBI::_get_dbh, avg 4.44ms/call # spent 93µs making 4 calls to DBI::db::get_info, avg 23µs/call # spent 64µs making 4 calls to DBD::SQLite::db::get_info, avg 16µs/call # spent 17.9ms making 4 calls to Try::Tiny::try, avg 4.48ms/call, recursion: max depth 1, sum of overlapping time 17.9ms
1117}
1118
1119
# spent 2.66ms (445µs+2.21) within DBIx::Class::Storage::DBI::_determine_driver which was called 13 times, avg 205µs/call: # 6 times (417µs+2.21ms) by DBIx::Class::Storage::DBI::deployment_statements or DBIx::Class::Storage::DBI::select or DBIx::Class::Storage::DBI::sql_maker at line 121, avg 439µs/call # 6 times (25µs+0s) by DBIx::Class::Storage::DBI::_populate_dbh at line 1012, avg 4µs/call # once (3µs+0s) by DBIx::Class::Storage::DBI::_dbi_attrs_for_bind at line 1505
sub _determine_driver {
1120140518µs my ($self) = @_;
1121
11221500ns if ((not $self->_driver_determined) && (not $self->{_in_determine_driver})) {
# spent 500ns making 1 call to DBIx::Class::Storage::DBI::_driver_determined
1123 my $started_connected = 0;
1124 local $self->{_in_determine_driver} = 1;
1125
1126 if (ref($self) eq __PACKAGE__) {
1127 my $driver;
1128298µs if ($self->_dbh) { # we are connected
# spent 98µs making 2 calls to DBIx::Class::Storage::DBI::_dbh, avg 49µs/call
1129 $driver = $self->_dbh->{Driver}{Name};
1130 $started_connected = 1;
1131 } else {
1132 # if connect_info is a CODEREF, we have no choice but to connect
11331600ns if (ref $self->_dbi_connect_info->[0] &&
# spent 600ns making 1 call to DBIx::Class::Storage::DBI::_dbi_connect_info
1134 reftype $self->_dbi_connect_info->[0] eq 'CODE') {
1135 $self->_populate_dbh;
1136 $driver = $self->_dbh->{Driver}{Name};
1137 }
1138 else {
1139 # try to use dsn to not require being connected, the driver may still
1140 # force a connection in _rebless to determine version
1141 # (dsn may not be supplied at all if all we do is make a mock-schema)
11421600ns my $dsn = $self->_dbi_connect_info->[0] || $ENV{DBI_DSN} || '';
# spent 600ns making 1 call to DBIx::Class::Storage::DBI::_dbi_connect_info
1143656µs ($driver) = $dsn =~ /dbi:([^:]+):/i;
# spent 56µs making 6 calls to DBIx::Class::Storage::DBI::CORE:match, avg 9µs/call
1144 $driver ||= $ENV{DBI_DRIVER};
1145 }
1146 }
1147
1148 if ($driver) {
1149 my $storage_class = "DBIx::Class::Storage::DBI::${driver}";
115062.00ms if ($self->load_optional_class($storage_class)) {
# spent 2.00ms making 6 calls to Class::C3::Componentised::load_optional_class, avg 334µs/call
1151629µs mro::set_mro($storage_class, 'c3');
# spent 29µs making 6 calls to mro::set_mro, avg 5µs/call
1152 bless $self, $storage_class;
1153613µs $self->_rebless();
# spent 13µs making 6 calls to DBIx::Class::Storage::DBI::_rebless, avg 2µs/call
1154 }
1155 }
1156 }
1157
115812µs $self->_driver_determined(1);
# spent 2µs making 1 call to DBIx::Class::Storage::DBI::_driver_determined
1159
1160 Class::C3->reinitialize() if DBIx::Class::_ENV_::OLD_MRO;
1161
116269µs $self->_init; # run driver-specific initializations
# spent 9µs making 6 calls to DBIx::Class::Storage::DBI::_init, avg 2µs/call
1163
116411µs $self->_run_connection_actions
# spent 1µs making 1 call to DBIx::Class::Storage::DBI::_dbh
1165 if !$started_connected && defined $self->_dbh;
1166 }
1167}
1168
1169sub _do_connection_actions {
1170 my $self = shift;
1171 my $method_prefix = shift;
1172 my $call = shift;
1173
1174 if (not ref($call)) {
1175 my $method = $method_prefix . $call;
1176 $self->$method(@_);
1177 } elsif (ref($call) eq 'CODE') {
1178 $self->$call(@_);
1179 } elsif (ref($call) eq 'ARRAY') {
1180 if (ref($call->[0]) ne 'ARRAY') {
1181 $self->_do_connection_actions($method_prefix, $_) for @$call;
1182 } else {
1183 $self->_do_connection_actions($method_prefix, @$_) for @$call;
1184 }
1185 } else {
1186 $self->throw_exception (sprintf ("Don't know how to process conection actions of type '%s'", ref($call)) );
1187 }
1188
1189 return $self;
1190}
1191
1192sub connect_call_do_sql {
1193 my $self = shift;
1194 $self->_do_query(@_);
1195}
1196
1197sub disconnect_call_do_sql {
1198 my $self = shift;
1199 $self->_do_query(@_);
1200}
1201
1202# override in db-specific backend when necessary
1203sub connect_call_datetime_setup { 1 }
1204
1205sub _do_query {
1206 my ($self, $action) = @_;
1207
1208 if (ref $action eq 'CODE') {
1209 $action = $action->($self);
1210 $self->_do_query($_) foreach @$action;
1211 }
1212 else {
1213 # Most debuggers expect ($sql, @bind), so we need to exclude
1214 # the attribute hash which is the second argument to $dbh->do
1215 # furthermore the bind values are usually to be presented
1216 # as named arrayref pairs, so wrap those here too
1217 my @do_args = (ref $action eq 'ARRAY') ? (@$action) : ($action);
1218 my $sql = shift @do_args;
1219 my $attrs = shift @do_args;
1220 my @bind = map { [ undef, $_ ] } @do_args;
1221
1222 $self->_query_start($sql, \@bind);
1223 $self->_get_dbh->do($sql, $attrs, @do_args);
1224 $self->_query_end($sql, \@bind);
1225 }
1226
1227 return $self;
1228}
1229
1230
# spent 20.2ms (265µs+19.9) within DBIx::Class::Storage::DBI::_connect which was called 6 times, avg 3.36ms/call: # 6 times (265µs+19.9ms) by DBIx::Class::Storage::DBI::_populate_dbh at line 1008, avg 3.36ms/call
sub _connect {
123142247µs my ($self, @info) = @_;
1232
1233 $self->throw_exception("You failed to provide any connection info")
1234 if !@info;
1235
1236 my ($old_connect_via, $dbh);
1237
1238 if ($INC{'Apache/DBI.pm'} && $ENV{MOD_PERL}) {
1239 $old_connect_via = $DBI::connect_via;
1240 $DBI::connect_via = 'connect';
1241 }
1242
1243
# spent 19.4ms (10.3+9.10) within DBIx::Class::Storage::DBI::__ANON__[/2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/site_perl/5.12.3/DBIx/Class/Storage/DBI.pm:1300] which was called 6 times, avg 3.23ms/call: # 6 times (10.3ms+9.10ms) by Try::Tiny::try at line 76 of Try/Tiny.pm, avg 3.23ms/call
try {
124448391µs if(ref $info[0] eq 'CODE') {
1245 $dbh = $info[0]->();
1246 }
1247 else {
1248 require DBI;
124967.17ms $dbh = DBI->connect(@info);
# spent 7.17ms making 6 calls to DBI::connect, avg 1.19ms/call
1250 }
1251
1252 if (!$dbh) {
1253 die $DBI::errstr;
1254 }
1255
12562175µs unless ($self->unsafe) {
# spent 173µs making 1 call to DBIx::Class::Storage::DBI::unsafe # spent 2µs making 1 call to DBIx::Class::Storage::DBI::SQLite::unsafe
1257
1258629µs $self->throw_exception(
# spent 29µs making 6 calls to DBI::common::FETCH, avg 5µs/call
1259 'Refusing clobbering of {HandleError} installed on externally supplied '
1260 ."DBI handle $dbh. Either remove the handler or use the 'unsafe' attribute."
1261 ) if $dbh->{HandleError} and ref $dbh->{HandleError} ne '__DBIC__DBH__ERROR__HANDLER__';
1262
1263 # Default via _default_dbi_connect_attributes is 1, hence it was an explicit
1264 # request, or an external handle. Complain and set anyway
1265610µs unless ($dbh->{RaiseError}) {
# spent 10µs making 6 calls to DBI::common::FETCH, avg 2µs/call
1266 carp( ref $info[0] eq 'CODE'
1267
1268 ? "The 'RaiseError' of the externally supplied DBI handle is set to false. "
1269 ."DBIx::Class will toggle it back to true, unless the 'unsafe' connect "
1270 .'attribute has been supplied'
1271
1272 : 'RaiseError => 0 supplied in your connection_info, without an explicit '
1273 .'unsafe => 1. Toggling RaiseError back to true'
1274 );
1275
1276 $dbh->{RaiseError} = 1;
1277 }
1278
1279 # this odd anonymous coderef dereference is in fact really
1280 # necessary to avoid the unwanted effect described in perl5
1281 # RT#75792
1282
# spent 144µs (118+26) within DBIx::Class::Storage::DBI::__ANON__[/2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/site_perl/5.12.3/DBIx/Class/Storage/DBI.pm:1298] which was called 6 times, avg 24µs/call: # 6 times (118µs+26µs) by DBIx::Class::Storage::DBI::__ANON__[/2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/site_perl/5.12.3/DBIx/Class/Storage/DBI.pm:1300] at line 1298, avg 24µs/call
sub {
128318155µs my $weak_self = $_[0];
1284612µs weaken $weak_self;
# spent 12µs making 6 calls to Scalar::Util::weaken, avg 2µs/call
1285
1286 # the coderef is blessed so we can distinguish it from externally
1287 # supplied handles (which must be preserved)
1288
# spent 4.63ms (29µs+4.60) within DBIx::Class::Storage::DBI::__ANON__[/2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/site_perl/5.12.3/DBIx/Class/Storage/DBI.pm:1297] which was called 2 times, avg 2.31ms/call: # 2 times (29µs+4.60ms) by DBI::db::prepare_cached at line 2252, avg 2.31ms/call
$_[1]->{HandleError} = bless sub {
1289222µs24.60ms if ($weak_self) {
# spent 4.60ms making 2 calls to DBIx::Class::Storage::throw_exception, avg 2.30ms/call
1290 $weak_self->throw_exception("DBI Exception: $_[0]");
1291 }
1292 else {
1293 # the handler may be invoked by something totally out of
1294 # the scope of DBIC
1295 DBIx::Class::Exception->throw("DBI Exception (unhandled by DBIC, ::Schema GCed): $_[0]");
1296 }
1297614µs }, '__DBIC__DBH__ERROR__HANDLER__';
# spent 14µs making 6 calls to DBI::common::STORE, avg 2µs/call
12986144µs }->($self, $dbh);
# spent 144µs making 6 calls to DBIx::Class::Storage::DBI::__ANON__[DBIx/Class/Storage/DBI.pm:1298], avg 24µs/call
1299 }
1300 }
1301 catch {
1302 $self->throw_exception("DBI Connection failed: $_")
1303 }
1304
# spent 11µs within DBIx::Class::Storage::DBI::__ANON__[/2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/site_perl/5.12.3/DBIx/Class/Storage/DBI.pm:1306] which was called 6 times, avg 2µs/call: # 6 times (11µs+0s) by Try::Tiny::ScopeGuard::DESTROY at line 144 of Try/Tiny.pm, avg 2µs/call
finally {
1305621µs $DBI::connect_via = $old_connect_via if $old_connect_via;
1306130µs24644µs };
# spent 19.7ms making 6 calls to Try::Tiny::try, avg 3.28ms/call, recursion: max depth 2, sum of overlapping time 19.2ms # spent 62µs making 6 calls to Try::Tiny::ScopeGuard::DESTROY, avg 10µs/call # spent 54µs making 6 calls to Try::Tiny::finally, avg 9µs/call # spent 30µs making 6 calls to Try::Tiny::catch, avg 5µs/call
1307
13088116µs $self->_dbh_autocommit($dbh->{AutoCommit});
# spent 99µs making 1 call to DBIx::Class::Storage::DBI::_dbh_autocommit # spent 11µs making 6 calls to DBI::common::FETCH, avg 2µs/call # spent 6µs making 1 call to DBIx::Class::Storage::DBI::SQLite::_dbh_autocommit
1309 $dbh;
1310}
1311
1312
# spent 61.8ms (8.34+53.4) within DBIx::Class::Storage::DBI::txn_begin which was called 588 times, avg 105µs/call: # 294 times (6.10ms+53.4ms) by DBIx::Class::Storage::TxnScopeGuard::new at line 131, avg 203µs/call # 294 times (2.24ms+0s) by DBIx::Class::Storage::TxnScopeGuard::new at line 30 of DBIx/Class/Storage/TxnScopeGuard.pm, avg 8µs/call
sub txn_begin {
131311764.69ms my $self = shift;
1314
1315 # this means we have not yet connected and do not know the AC status
1316 # (e.g. coderef $dbh), need a full-fledged connection check
131712µs if (! defined $self->_dbh_autocommit) {
1318 $self->ensure_connected;
1319 }
1320 # Otherwise simply connect or re-connect on pid changes
1321 else {
13222944.69ms $self->_get_dbh;
# spent 4.69ms making 294 calls to DBIx::Class::Storage::DBI::_get_dbh, avg 16µs/call
1323 }
1324
13252944.49ms $self->next::method(@_);
# spent 4.49ms making 294 calls to next::method, avg 15µs/call
1326}
1327
1328
# spent 38.5ms (3.34+35.2) within DBIx::Class::Storage::DBI::_exec_txn_begin which was called 294 times, avg 131µs/call: # 294 times (3.34ms+35.2ms) by DBIx::Class::Storage::txn_begin at line 276 of DBIx/Class/Storage.pm, avg 131µs/call
sub _exec_txn_begin {
13298823.08ms my $self = shift;
1330
1331 # if the user is utilizing txn_do - good for him, otherwise we need to
1332 # ensure that the $dbh is healthy on BEGIN.
1333 # We do this via ->dbh_do instead of ->dbh, so that the ->dbh "ping"
1334 # will be replaced by a failure of begin_work itself (which will be
1335 # then retried on reconnect)
1336 if ($self->{_in_do_block}) {
1337 $self->_dbh->begin_work;
1338 } else {
13392945.43ms88257.0ms
# spent 14.3ms (1.95+12.4) within DBIx::Class::Storage::DBI::__ANON__[/2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/site_perl/5.12.3/DBIx/Class/Storage/DBI.pm:1339] which was called 294 times, avg 49µs/call: # 294 times (1.95ms+12.4ms) by DBIx::Class::Storage::DBI::__ANON__[/2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/site_perl/5.12.3/DBIx/Class/Storage/DBI.pm:790] at line 789, avg 49µs/call
$self->dbh_do(sub { $_[1]->begin_work });
# spent 35.2ms making 294 calls to DBIx::Class::Storage::DBI::dbh_do, avg 120µs/call # spent 12.4ms making 294 calls to DBI::db::begin_work, avg 42µs/call # spent 9.39ms making 294 calls to DBD::_::db::begin_work, avg 32µs/call
1340 }
1341}
1342
1343
# spent 34.9s (10.6ms+34.9) within DBIx::Class::Storage::DBI::txn_commit which was called 294 times, avg 119ms/call: # 294 times (10.6ms+34.9s) by DBIx::Class::Storage::TxnScopeGuard::commit at line 81 of DBIx/Class/Storage/TxnScopeGuard.pm, avg 119ms/call
sub txn_commit {
134417649.00ms my $self = shift;
1345
1346295726µs $self->_verify_pid if $self->_dbh;
# spent 725µs making 294 calls to DBIx::Class::Storage::DBI::_verify_pid, avg 2µs/call # spent 1µs making 1 call to DBIx::Class::Storage::DBI::_dbh
13471600ns $self->throw_exception("Unable to txn_commit() on a disconnected storage")
# spent 600ns making 1 call to DBIx::Class::Storage::DBI::_dbh
1348 unless $self->_dbh;
1349
1350 # esoteric case for folks using external $dbh handles
135111µs if (! $self->transaction_depth and ! $self->_dbh->FETCH('AutoCommit') ) {
1352 carp "Storage transaction_depth 0 does not match "
1353 ."false AutoCommit of $self->{_dbh}, attempting COMMIT anyway";
1354 $self->transaction_depth(1);
1355 }
1356
13572942.83ms $self->next::method(@_);
# spent 2.83ms making 294 calls to next::method, avg 10µs/call
1358
1359 # if AutoCommit is disabled txn_depth never goes to 0
1360 # as a new txn is started immediately on commit
136137µs $self->transaction_depth(1) if (
# spent 5µs making 1 call to DBIx::Class::Storage::DBI::SQLite::transaction_depth # spent 2µs making 2 calls to DBIx::Class::Storage::DBI::SQLite::_dbh_autocommit, avg 1µs/call
1362 !$self->transaction_depth
1363 and
1364 defined $self->_dbh_autocommit
1365 and
1366 ! $self->_dbh_autocommit
1367 );
1368}
1369
1370
# spent 34.8s (9.80ms+34.8) within DBIx::Class::Storage::DBI::_exec_txn_commit which was called 294 times, avg 119ms/call: # 294 times (9.80ms+34.8s) by DBIx::Class::Storage::txn_commit at line 299 of DBIx/Class/Storage.pm, avg 119ms/call
sub _exec_txn_commit {
137129434.8s29534.8s shift->_dbh->commit;
# spent 34.8s making 294 calls to DBI::db::commit, avg 118ms/call # spent 500ns making 1 call to DBIx::Class::Storage::DBI::_dbh
1372}
1373
1374sub txn_rollback {
1375 my $self = shift;
1376
1377 $self->_verify_pid if $self->_dbh;
1378 $self->throw_exception("Unable to txn_rollback() on a disconnected storage")
1379 unless $self->_dbh;
1380
1381 # esoteric case for folks using external $dbh handles
1382 if (! $self->transaction_depth and ! $self->_dbh->FETCH('AutoCommit') ) {
1383 carp "Storage transaction_depth 0 does not match "
1384 ."false AutoCommit of $self->{_dbh}, attempting ROLLBACK anyway";
1385 $self->transaction_depth(1);
1386 }
1387
1388 $self->next::method(@_);
1389
1390 # if AutoCommit is disabled txn_depth never goes to 0
1391 # as a new txn is started immediately on commit
1392 $self->transaction_depth(1) if (
1393 !$self->transaction_depth
1394 and
1395 defined $self->_dbh_autocommit
1396 and
1397 ! $self->_dbh_autocommit
1398 );
1399}
1400
1401sub _exec_txn_rollback {
1402 shift->_dbh->rollback;
1403}
1404
1405# generate some identical methods
140611µsfor my $meth (qw/svp_begin svp_release svp_rollback/) {
140735.17ms264µs
# spent 39µs (14+25) within DBIx::Class::Storage::DBI::BEGIN@1407 which was called: # once (14µs+25µs) by Class::C3::Componentised::ensure_class_loaded at line 1407
no strict qw/refs/;
# spent 39µs making 1 call to DBIx::Class::Storage::DBI::BEGIN@1407 # spent 25µs making 1 call to strict::unimport
1408 *{__PACKAGE__ ."::$meth"} = subname $meth => sub {
1409 my $self = shift;
1410 $self->_verify_pid if $self->_dbh;
1411 $self->throw_exception("Unable to $meth() on a disconnected storage")
1412 unless $self->_dbh;
1413 $self->next::method(@_);
1414328µs35µs };
# spent 5µs making 3 calls to Sub::Name::subname, avg 2µs/call
1415}
1416
1417# This used to be the top-half of _execute. It was split out to make it
1418# easier to override in NoBindVars without duping the rest. It takes up
1419# all of _execute's args, and emits $sql, @bind.
1420
# spent 8.68s (54.7ms+8.62) within DBIx::Class::Storage::DBI::_prep_for_execute which was called 8019 times, avg 1.08ms/call: # 8019 times (54.7ms+8.62s) by DBIx::Class::Storage::DBI::_execute at line 1555, avg 1.08ms/call
sub _prep_for_execute {
1421 #my ($self, $op, $ident, $args) = @_;
1422801948.0ms80198.62s return shift->_gen_sql_bind(@_)
# spent 8.62s making 8019 calls to DBIx::Class::Storage::DBI::_gen_sql_bind, avg 1.08ms/call
1423}
1424
1425
# spent 8.62s (460ms+8.17) within DBIx::Class::Storage::DBI::_gen_sql_bind which was called 8019 times, avg 1.08ms/call: # 8019 times (460ms+8.17s) by DBIx::Class::Storage::DBI::_prep_for_execute at line 1422, avg 1.08ms/call
sub _gen_sql_bind {
142681583417ms my ($self, $op, $ident, $args) = @_;
1427
1428253705.85s my ($sql, @bind) = $self->sql_maker->$op(
# spent 4.80s making 6706 calls to DBIx::Class::SQLMaker::select, avg 715µs/call # spent 576ms making 845 calls to SQL::Abstract::update, avg 682µs/call # spent 431ms making 449 calls to DBIx::Class::SQLMaker::insert, avg 961µs/call # spent 20.5ms making 8019 calls to DBIx::Class::Storage::DBI::sql_maker, avg 3µs/call # spent 10.0ms making 8019 calls to Scalar::Util::blessed, avg 1µs/call # spent 8.00ms making 1313 calls to DBIx::Class::ResultSource::Table::from, avg 6µs/call # spent 7.67ms making 19 calls to SQL::Abstract::delete, avg 403µs/call
1429 blessed($ident) ? $ident->from : $ident,
1430 @$args,
1431 );
1432
1433 my (@final_bind, $colinfos);
1434
# spent 2.29s (123ms+2.17) within DBIx::Class::Storage::DBI::__ANON__[/2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/site_perl/5.12.3/DBIx/Class/Storage/DBI.pm:1443] which was called 11153 times, avg 205µs/call: # 11153 times (123ms+2.17s) by DBIx::Class::Storage::DBI::_gen_sql_bind at line 1463, avg 205µs/call
my $resolve_bindinfo = sub {
143555765124ms76312.17s $colinfos ||= $self->_resolve_column_info($ident);
# spent 2.17s making 7631 calls to DBIx::Class::Storage::DBIHacks::_resolve_column_info, avg 284µs/call
1436 if (my $col = $_[1]->{dbic_colname}) {
1437 $_[1]->{sqlt_datatype} ||= $colinfos->{$col}{data_type}
1438 if $colinfos->{$col}{data_type};
1439 $_[1]->{sqlt_size} ||= $colinfos->{$col}{size}
1440 if $colinfos->{$col}{size};
1441 }
1442 $_[1];
1443 };
1444
1445 for my $e (@{$args->[2]{bind}||[]}, @bind) {
1446 push @final_bind, [ do {
1447534µs if (ref $e ne 'ARRAY') {
# spent 34µs making 5 calls to List::Util::first, avg 7µs/call
1448 ({}, $e)
1449 }
1450 elsif (! defined $e->[0]) {
1451 ({}, $e->[1])
1452 }
1453 elsif (ref $e->[0] eq 'HASH') {
1454 (
14551046µs (first { $e->[0]{$_} } qw/dbd_attrs sqlt_datatype/) ? $e->[0] : $self->$resolve_bindinfo($e->[0]),
1456 $e->[1]
1457 )
1458 }
1459 elsif (ref $e->[0] eq 'SCALAR') {
1460 ( { sqlt_datatype => ${$e->[0]} }, $e->[1] )
1461 }
1462 else {
1463111532.29s ( $self->$resolve_bindinfo({ dbic_colname => $e->[0] }), $e->[1] )
# spent 2.29s making 11153 calls to DBIx::Class::Storage::DBI::__ANON__[DBIx/Class/Storage/DBI.pm:1443], avg 205µs/call
1464 }
1465 }];
1466 }
1467
1468 ($sql, \@final_bind);
1469}
1470
1471sub _format_for_trace {
1472 #my ($self, $bind) = @_;
1473
1474 ### Turn @bind from something like this:
1475 ### ( [ "artist", 1 ], [ \%attrs, 3 ] )
1476 ### to this:
1477 ### ( "'1'", "'3'" )
1478
1479 map {
1480 defined( $_ && $_->[1] )
1481 ? qq{'$_->[1]'}
1482 : q{NULL}
1483 } @{$_[1] || []};
1484}
1485
1486
# spent 35.4ms (34.6+796µs) within DBIx::Class::Storage::DBI::_query_start which was called 8090 times, avg 4µs/call: # 8019 times (34.0ms+0s) by DBIx::Class::Storage::DBI::_dbh_execute at line 1568, avg 4µs/call # 71 times (528µs+796µs) by DBIx::Class::Storage::DBI::__ANON__[/2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/site_perl/5.12.3/DBIx/Class/Storage/DBI.pm:2767] at line 2758, avg 19µs/call
sub _query_start {
14871618051.3ms my ( $self, $sql, $bind ) = @_;
1488
14892796µs $self->debugobj->query_start( $sql, $self->_format_for_trace($bind) )
# spent 794µs making 1 call to DBIx::Class::Storage::debug # spent 2µs making 1 call to DBIx::Class::Storage::DBI::SQLite::debug
1490 if $self->debug;
1491}
1492
1493
# spent 54.2ms (54.2+5µs) within DBIx::Class::Storage::DBI::_query_end which was called 8088 times, avg 7µs/call: # 8017 times (53.0ms+0s) by DBIx::Class::Storage::DBI::_dbh_execute at line 1598, avg 7µs/call # 71 times (1.21ms+5µs) by DBIx::Class::Storage::DBI::__ANON__[/2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/site_perl/5.12.3/DBIx/Class/Storage/DBI.pm:2767] at line 2766, avg 17µs/call
sub _query_end {
14941617668.1ms my ( $self, $sql, $bind ) = @_;
1495
149615µs $self->debugobj->query_end( $sql, $self->_format_for_trace($bind) )
# spent 5µs making 1 call to DBIx::Class::Storage::DBI::SQLite::debug
1497 if $self->debug;
1498}
1499
15001400nsmy $sba_compat;
1501
# spent 142ms (142+193µs) within DBIx::Class::Storage::DBI::_dbi_attrs_for_bind which was called 8019 times, avg 18µs/call: # 8019 times (142ms+193µs) by DBIx::Class::Storage::DBI::SQLite::_dbi_attrs_for_bind at line 28 of mro.pm, avg 18µs/call
sub _dbi_attrs_for_bind {
1502111925160ms my ($self, $ident, $bind) = @_;
1503
1504 if (! defined $sba_compat) {
150513µs $self->_determine_driver;
# spent 3µs making 1 call to DBIx::Class::Storage::DBI::_determine_driver
150614µs $sba_compat = $self->can('source_bind_attributes') == \&source_bind_attributes
# spent 4µs making 1 call to UNIVERSAL::can
1507 ? 0
1508 : 1
1509 ;
1510 }
1511
1512 my $sba_attrs;
1513 if ($sba_compat) {
1514 my $class = ref $self;
1515 carp_unique (
1516 "The source_bind_attributes() override in $class relies on a deprecated codepath. "
1517 .'You are strongly advised to switch your code to override bind_attribute_by_datatype() '
1518 .'instead. This legacy compat shim will also disappear some time before DBIC 0.09'
1519 );
1520
1521 my $sba_attrs = $self->source_bind_attributes
1522 }
1523
1524 my @attrs;
1525
1526 for (map { $_->[0] } @$bind) {
1527 push @attrs, do {
1528 if (exists $_->{dbd_attrs}) {
1529 $_->{dbd_attrs}
1530 }
1531 elsif($_->{sqlt_datatype}) {
1532 # cache the result in the dbh_details hash, as it can not change unless
1533 # we connect to something else
153412µs my $cache = $self->_dbh_details->{_datatype_map_cache} ||= {};
# spent 2µs making 1 call to DBIx::Class::Storage::DBI::_dbh_details
153514185µs if (not exists $cache->{$_->{sqlt_datatype}}) {
# spent 185µs making 14 calls to DBIx::Class::Storage::DBI::SQLite::bind_attribute_by_data_type, avg 13µs/call
1536 $cache->{$_->{sqlt_datatype}} = $self->bind_attribute_by_data_type($_->{sqlt_datatype}) || undef;
1537 }
1538 $cache->{$_->{sqlt_datatype}};
1539 }
1540 elsif ($sba_attrs and $_->{dbic_colname}) {
1541 $sba_attrs->{$_->{dbic_colname}} || undef;
1542 }
1543 else {
1544 undef; # always push something at this position
1545 }
1546 }
1547 }
1548
1549 return \@attrs;
1550}
1551
1552
# spent 127s (159ms+127) within DBIx::Class::Storage::DBI::_execute which was called 8019 times, avg 15.9ms/call: # 6706 times (118ms+8.78s) by DBIx::Class::Storage::DBI::_select at line 2084, avg 1.33ms/call # 845 times (27.0ms+80.4s) by DBIx::Class::Storage::DBI::update at line 1976, avg 95.2ms/call # 449 times (13.9ms+36.0s) by DBIx::Class::Storage::DBI::insert at line 1671, avg 80.1ms/call # 19 times (807µs+2.15s) by DBIx::Class::Storage::DBI::delete at line 1982, avg 113ms/call
sub _execute {
155324057148ms my ($self, $op, $ident, @args) = @_;
1554
155580198.68s my ($sql, $bind) = $self->_prep_for_execute($op, $ident, \@args);
# spent 8.68s making 8019 calls to DBIx::Class::Storage::DBI::_prep_for_execute, avg 1.08ms/call
1556
1557 shift->dbh_do( # retry over disconnects
155816038118s '_dbh_execute',
# spent 118s making 8019 calls to DBIx::Class::Storage::DBI::dbh_do, avg 14.7ms/call, recursion: max depth 1, sum of overlapping time 1.01s # spent 456ms making 8019 calls to DBIx::Class::Storage::DBI::SQLite::_dbi_attrs_for_bind, avg 57µs/call
1559 $sql,
1560 $bind,
1561 $self->_dbi_attrs_for_bind($ident, $bind)
1562 );
1563}
1564
1565
# spent 118s (349ms+117) within DBIx::Class::Storage::DBI::_dbh_execute which was called 8019 times, avg 14.7ms/call: # 4993 times (163ms+848ms) by DBIx::Class::Storage::DBI::dbh_do at line 780, avg 202µs/call # 3026 times (186ms+117s) by DBIx::Class::Storage::DBI::__ANON__[/2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/site_perl/5.12.3/DBIx/Class/Storage/DBI.pm:790] at line 789, avg 38.6ms/call
sub _dbh_execute {
156686454117s my ($self, undef, $sql, $bind, $bind_attrs) = @_;
1567
1568801934.0ms $self->_query_start( $sql, $bind );
# spent 34.0ms making 8019 calls to DBIx::Class::Storage::DBI::_query_start, avg 4µs/call
15698019652ms my $sth = $self->_sth($sql);
# spent 652ms making 8019 calls to DBIx::Class::Storage::DBI::_sth, avg 81µs/call
1570
1571 for my $i (0 .. $#$bind) {
1572 if (ref $bind->[$i][1] eq 'SCALAR') { # any scalarrefs are assumed to be bind_inouts
1573 $sth->bind_param_inout(
1574 $i + 1, # bind params counts are 1-based
1575 $bind->[$i][1],
1576 $bind->[$i][0]{dbd_size} || $self->_max_column_bytesize($bind->[$i][0]), # size
1577 $bind_attrs->[$i],
1578 );
1579 }
1580 else {
15811115637.6ms $sth->bind_param(
# spent 37.6ms making 11156 calls to DBI::st::bind_param, avg 3µs/call
1582 $i + 1,
1583 (ref $bind->[$i][1] and overload::Method($bind->[$i][1], '""'))
1584 ? "$bind->[$i][1]"
1585 : $bind->[$i][1]
1586 ,
1587 $bind_attrs->[$i],
1588 );
1589 }
1590 }
1591
1592 # Can this fail without throwing an exception anyways???
15938017117s my $rv = $sth->execute();
# spent 117s making 8017 calls to DBI::st::execute, avg 14.5ms/call
1594 $self->throw_exception(
1595 $sth->errstr || $sth->err || 'Unknown error: execute() returned false, but error flags were not set...'
1596 ) if !$rv;
1597
1598801753.0ms $self->_query_end( $sql, $bind );
# spent 53.0ms making 8017 calls to DBIx::Class::Storage::DBI::_query_end, avg 7µs/call
1599
1600 return (wantarray ? ($rv, $sth, @$bind) : $rv);
1601}
1602
1603
# spent 36.4ms (12.9+23.4) within DBIx::Class::Storage::DBI::_prefetch_autovalues which was called 449 times, avg 81µs/call: # 449 times (12.9ms+23.4ms) by DBIx::Class::Storage::DBI::insert at line 1636, avg 81µs/call
sub _prefetch_autovalues {
1604618712.6ms my ($self, $source, $to_insert) = @_;
1605
160644923.4ms my $colinfo = $source->columns_info;
# spent 23.4ms making 449 calls to DBIx::Class::ResultSource::columns_info, avg 52µs/call
1607
1608 my %values;
1609 for my $col (keys %$colinfo) {
1610 if (
1611 $colinfo->{$col}{auto_nextval}
1612 and
1613 (
1614 ! exists $to_insert->{$col}
1615 or
1616 ref $to_insert->{$col} eq 'SCALAR'
1617 or
1618 (ref $to_insert->{$col} eq 'REF' and ref ${$to_insert->{$col}} eq 'ARRAY')
1619 )
1620 ) {
1621 $values{$col} = $self->_sequence_fetch(
1622 'NEXTVAL',
1623 ( $colinfo->{$col}{sequence} ||=
1624 $self->_dbh_get_autoinc_seq($self->_get_dbh, $source, $col)
1625 ),
1626 );
1627 }
1628 }
1629
1630 \%values;
1631}
1632
1633
# spent 36.2s (78.2ms+36.1) within DBIx::Class::Storage::DBI::insert which was called 898 times, avg 40.3ms/call: # 449 times (74.0ms+36.1s) by DBIx::Class::Row::insert at line 131, avg 80.6ms/call # 449 times (4.13ms+0s) by DBIx::Class::Row::insert at line 350 of DBIx/Class/Row.pm, avg 9µs/call
sub insert {
16341472169.4ms my ($self, $source, $to_insert) = @_;
1635
163644936.4ms my $prefetched_values = $self->_prefetch_autovalues($source, $to_insert);
# spent 36.4ms making 449 calls to DBIx::Class::Storage::DBI::_prefetch_autovalues, avg 81µs/call
1637
1638 # fuse the values, but keep a separate list of prefetched_values so that
1639 # they can be fused once again with the final return
1640 $to_insert = { %$to_insert, %$prefetched_values };
1641
164244913.8ms my $col_infos = $source->columns_info;
# spent 13.8ms making 449 calls to DBIx::Class::ResultSource::columns_info, avg 31µs/call
16434493.22ms my %pcols = map { $_ => 1 } $source->primary_columns;
# spent 3.22ms making 449 calls to DBIx::Class::ResultSource::primary_columns, avg 7µs/call
1644 my %retrieve_cols;
16454494.60ms for my $col ($source->columns) {
# spent 4.60ms making 449 calls to DBIx::Class::ResultSource::columns, avg 10µs/call
1646 # nothing to retrieve when explicit values are supplied
1647 next if (defined $to_insert->{$col} and ! (
1648 ref $to_insert->{$col} eq 'SCALAR'
1649 or
1650 (ref $to_insert->{$col} eq 'REF' and ref ${$to_insert->{$col}} eq 'ARRAY')
1651 ));
1652
1653 # the 'scalar keys' is a trick to preserve the ->columns declaration order
1654 $retrieve_cols{$col} = scalar keys %retrieve_cols if (
1655 $pcols{$col}
1656 or
1657 $col_infos->{$col}{retrieve_on_insert}
1658 );
1659 };
1660
1661 my ($sqla_opts, @ir_container);
166229642.4ms if (%retrieve_cols and $self->_use_insert_returning) {
# spent 42.4ms making 296 calls to DBIx::Class::Storage::DBI::_use_insert_returning, avg 143µs/call
1663 $sqla_opts->{returning_container} = \@ir_container
1664 if $self->_use_insert_returning_bound;
1665
1666 $sqla_opts->{returning} = [
1667 sort { $retrieve_cols{$a} <=> $retrieve_cols{$b} } keys %retrieve_cols
1668 ];
1669 }
1670
167144936.0s my ($rv, $sth) = $self->_execute('insert', $source, $to_insert, $sqla_opts);
# spent 36.0s making 449 calls to DBIx::Class::Storage::DBI::_execute, avg 80.1ms/call
1672
1673 my %returned_cols = %$to_insert;
1674 if (my $retlist = $sqla_opts->{returning}) { # if IR is supported - we will get everything in one set
1675 @ir_container = try {
1676 local $SIG{__WARN__} = sub {};
1677 my @r = $sth->fetchrow_array;
1678 $sth->finish;
1679 @r;
1680 } unless @ir_container;
1681
1682 @returned_cols{@$retlist} = @ir_container if @ir_container;
1683 }
1684 else {
1685 # pull in PK if needed and then everything else
1686 if (my @missing_pri = grep { $pcols{$_} } keys %retrieve_cols) {
1687
16882961.28ms $self->throw_exception( "Missing primary key but Storage doesn't support last_insert_id" )
# spent 1.28ms making 296 calls to UNIVERSAL::can, avg 4µs/call
1689 unless $self->can('last_insert_id');
1690
169129623.5ms my @pri_values = $self->last_insert_id($source, @missing_pri);
# spent 23.5ms making 296 calls to DBIx::Class::Storage::DBI::last_insert_id, avg 79µs/call
1692
1693 $self->throw_exception( "Can't get last insert id" )
1694 unless (@pri_values == @missing_pri);
1695
1696 @returned_cols{@missing_pri} = @pri_values;
1697 delete $retrieve_cols{$_} for @missing_pri;
1698 }
1699
1700 # if there is more left to pull
1701 if (%retrieve_cols) {
1702 $self->throw_exception(
1703 'Unable to retrieve additional columns without a Primary Key on ' . $source->source_name
1704 ) unless %pcols;
1705
1706 my @left_to_fetch = sort { $retrieve_cols{$a} <=> $retrieve_cols{$b} } keys %retrieve_cols;
1707
1708 my $cur = DBIx::Class::ResultSet->new($source, {
1709 where => { map { $_ => $returned_cols{$_} } (keys %pcols) },
1710 select => \@left_to_fetch,
1711 })->cursor;
1712
1713 @returned_cols{@left_to_fetch} = $cur->next;
1714
1715 $self->throw_exception('Duplicate row returned for PK-search after fresh insert')
1716 if scalar $cur->next;
1717 }
1718 }
1719
1720 return { %$prefetched_values, %returned_cols };
1721}
1722
1723sub insert_bulk {
1724 my ($self, $source, $cols, $data) = @_;
1725
1726 # FIXME - perhaps this is not even needed? does DBI stringify?
1727 #
1728 # forcibly stringify whatever is stringifiable
1729 for my $r (0 .. $#$data) {
1730 for my $c (0 .. $#{$data->[$r]}) {
1731 $data->[$r][$c] = "$data->[$r][$c]"
1732 if ( ref $data->[$r][$c] and overload::Method($data->[$r][$c], '""') );
1733 }
1734 }
1735
1736 # check the data for consistency
1737 # report a sensible error on bad data
1738 #
1739 # also create a list of dynamic binds (ones that will be changing
1740 # for each row)
1741 my $dyn_bind_idx;
1742 for my $col_idx (0..$#$cols) {
1743
1744 # the first "row" is used as a point of reference
1745 my $reference_val = $data->[0][$col_idx];
1746 my $is_literal = ref $reference_val eq 'SCALAR';
1747 my $is_literal_bind = ( !$is_literal and (
1748 ref $reference_val eq 'REF'
1749 and
1750 ref $$reference_val eq 'ARRAY'
1751 ) );
1752
1753 $dyn_bind_idx->{$col_idx} = 1
1754 if (!$is_literal and !$is_literal_bind);
1755
1756 # use a closure for convenience (less to pass)
1757 my $bad_slice = sub {
1758 my ($msg, $slice_idx) = @_;
1759 $self->throw_exception(sprintf "%s for column '%s' in populate slice:\n%s",
1760 $msg,
1761 $cols->[$col_idx],
1762 do {
1763 require Data::Dumper::Concise;
1764 local $Data::Dumper::Maxdepth = 2;
1765 Data::Dumper::Concise::Dumper ({
1766 map { $cols->[$_] =>
1767 $data->[$slice_idx][$_]
1768 } (0 .. $#$cols)
1769 }),
1770 }
1771 );
1772 };
1773
1774 for my $row_idx (1..$#$data) { # we are comparing against what we got from [0] above, hence start from 1
1775 my $val = $data->[$row_idx][$col_idx];
1776
1777 if ($is_literal) {
1778 if (ref $val ne 'SCALAR') {
1779 $bad_slice->(
1780 "Incorrect value (expecting SCALAR-ref \\'$$reference_val')",
1781 $row_idx
1782 );
1783 }
1784 elsif ($$val ne $$reference_val) {
1785 $bad_slice->(
1786 "Inconsistent literal SQL value (expecting \\'$$reference_val')",
1787 $row_idx
1788 );
1789 }
1790 }
1791 elsif ($is_literal_bind) {
1792 if (ref $val ne 'REF' or ref $$val ne 'ARRAY') {
1793 $bad_slice->(
1794 "Incorrect value (expecting ARRAYREF-ref \\['${$reference_val}->[0]', ... ])",
1795 $row_idx
1796 );
1797 }
1798 elsif (${$val}->[0] ne ${$reference_val}->[0]) {
1799 $bad_slice->(
1800 "Inconsistent literal SQL-bind value (expecting \\['${$reference_val}->[0]', ... ])",
1801 $row_idx
1802 );
1803 }
1804 }
1805 elsif (ref $val) {
1806 if (ref $val eq 'SCALAR' or (ref $val eq 'REF' and ref $$val eq 'ARRAY') ) {
1807 $bad_slice->("Literal SQL found where a plain bind value is expected", $row_idx);
1808 }
1809 else {
1810 $bad_slice->("$val reference found where bind expected", $row_idx);
1811 }
1812 }
1813 }
1814 }
1815
1816 # Get the sql with bind values interpolated where necessary. For dynamic
1817 # binds convert the values of the first row into a literal+bind combo, with
1818 # extra positional info in the bind attr hashref. This will allow us to match
1819 # the order properly, and is so contrived because a user-supplied literal
1820 # bind (or something else specific to a resultsource and/or storage driver)
1821 # can inject extra binds along the way, so one can't rely on "shift
1822 # positions" ordering at all. Also we can't just hand SQLA a set of some
1823 # known "values" (e.g. hashrefs that can be later matched up by address),
1824 # because we want to supply a real value on which perhaps e.g. datatype
1825 # checks will be performed
1826 my ($sql, $proto_bind) = $self->_prep_for_execute (
1827 'insert',
1828 $source,
1829 [ { map { $cols->[$_] => $dyn_bind_idx->{$_}
1830 ? \[ '?', [
1831 { dbic_colname => $cols->[$_], _bind_data_slice_idx => $_ }
1832 =>
1833 $data->[0][$_]
1834 ] ]
1835 : $data->[0][$_]
1836 } (0..$#$cols) } ],
1837 );
1838
1839 if (! @$proto_bind and keys %$dyn_bind_idx) {
1840 # if the bindlist is empty and we had some dynamic binds, this means the
1841 # storage ate them away (e.g. the NoBindVars component) and interpolated
1842 # them directly into the SQL. This obviosly can't be good for multi-inserts
1843 $self->throw_exception('Cannot insert_bulk without support for placeholders');
1844 }
1845
1846 # neither _execute_array, nor _execute_inserts_with_no_binds are
1847 # atomic (even if _execute _array is a single call). Thus a safety
1848 # scope guard
1849 my $guard = $self->txn_scope_guard;
1850
1851 $self->_query_start( $sql, @$proto_bind ? [[undef => '__BULK_INSERT__' ]] : () );
1852 my $sth = $self->_sth($sql);
1853 my $rv = do {
1854 if (@$proto_bind) {
1855 # proto bind contains the information on which pieces of $data to pull
1856 # $cols is passed in only for prettier error-reporting
1857 $self->_execute_array( $source, $sth, $proto_bind, $cols, $data );
1858 }
1859 else {
1860 # bind_param_array doesn't work if there are no binds
1861 $self->_dbh_execute_inserts_with_no_binds( $sth, scalar @$data );
1862 }
1863 };
1864
1865 $self->_query_end( $sql, @$proto_bind ? [[ undef => '__BULK_INSERT__' ]] : () );
1866
1867 $guard->commit;
1868
1869 return (wantarray ? ($rv, $sth, @$proto_bind) : $rv);
1870}
1871
1872sub _execute_array {
1873 my ($self, $source, $sth, $proto_bind, $cols, $data, @extra) = @_;
1874
1875 ## This must be an arrayref, else nothing works!
1876 my $tuple_status = [];
1877
1878 my $bind_attrs = $self->_dbi_attrs_for_bind($source, $proto_bind);
1879
1880 # Bind the values by column slices
1881 for my $i (0 .. $#$proto_bind) {
1882 my $data_slice_idx = (
1883 ref $proto_bind->[$i][0] eq 'HASH'
1884 and
1885 exists $proto_bind->[$i][0]{_bind_data_slice_idx}
1886 ) ? $proto_bind->[$i][0]{_bind_data_slice_idx} : undef;
1887
1888 $sth->bind_param_array(
1889 $i+1, # DBI bind indexes are 1-based
1890 defined $data_slice_idx
1891 # either get a "column" of dynamic values, or just repeat the same
1892 # bind over and over
1893 ? [ map { $_->[$data_slice_idx] } @$data ]
1894 : [ ($proto_bind->[$i][1]) x @$data ]
1895 ,
1896 defined $bind_attrs->[$i] ? $bind_attrs->[$i] : (), # some DBDs throw up when given an undef
1897 );
1898 }
1899
1900 my ($rv, $err);
1901 try {
1902 $rv = $self->_dbh_execute_array($sth, $tuple_status, @extra);
1903 }
1904 catch {
1905 $err = shift;
1906 };
1907
1908 # Not all DBDs are create equal. Some throw on error, some return
1909 # an undef $rv, and some set $sth->err - try whatever we can
1910 $err = ($sth->errstr || 'UNKNOWN ERROR ($sth->errstr is unset)') if (
1911 ! defined $err
1912 and
1913 ( !defined $rv or $sth->err )
1914 );
1915
1916 # Statement must finish even if there was an exception.
1917 try {
1918 $sth->finish
1919 }
1920 catch {
1921 $err = shift unless defined $err
1922 };
1923
1924 if (defined $err) {
1925 my $i = 0;
1926 ++$i while $i <= $#$tuple_status && !ref $tuple_status->[$i];
1927
1928 $self->throw_exception("Unexpected populate error: $err")
1929 if ($i > $#$tuple_status);
1930
1931 require Data::Dumper::Concise;
1932 $self->throw_exception(sprintf "execute_array() aborted with '%s' at populate slice:\n%s",
1933 ($tuple_status->[$i][1] || $err),
1934 Data::Dumper::Concise::Dumper( { map { $cols->[$_] => $data->[$i][$_] } (0 .. $#$cols) } ),
1935 );
1936 }
1937
1938 return $rv;
1939}
1940
1941sub _dbh_execute_array {
1942 #my ($self, $sth, $tuple_status, @extra) = @_;
1943 return $_[1]->execute_array({ArrayTupleStatus => $_[2]});
1944}
1945
1946sub _dbh_execute_inserts_with_no_binds {
1947 my ($self, $sth, $count) = @_;
1948
1949 my $err;
1950 try {
1951 my $dbh = $self->_get_dbh;
1952 local $dbh->{RaiseError} = 1;
1953 local $dbh->{PrintError} = 0;
1954
1955 $sth->execute foreach 1..$count;
1956 }
1957 catch {
1958 $err = shift;
1959 };
1960
1961 # Make sure statement is finished even if there was an exception.
1962 try {
1963 $sth->finish
1964 }
1965 catch {
1966 $err = shift unless defined $err;
1967 };
1968
1969 $self->throw_exception($err) if defined $err;
1970
1971 return $count;
1972}
1973
1974
# spent 80.5s (15.8ms+80.4) within DBIx::Class::Storage::DBI::update which was called 1690 times, avg 47.6ms/call: # 845 times (8.99ms+80.4s) by DBIx::Class::Row::update at line 131, avg 95.2ms/call # 845 times (6.81ms+0s) by DBIx::Class::Row::update at line 503 of DBIx/Class/Row.pm, avg 8µs/call
sub update {
1975 #my ($self, $source, @args) = @_;
19768459.25ms84580.4s shift->_execute('update', @_);
# spent 80.4s making 845 calls to DBIx::Class::Storage::DBI::_execute, avg 95.2ms/call
1977}
1978
1979
1980
# spent 2.15s (470µs+2.15) within DBIx::Class::Storage::DBI::delete which was called 38 times, avg 56.6ms/call: # 19 times (251µs+2.15s) by DBIx::Class::ResultSet::_rs_update_delete at line 131, avg 113ms/call # 19 times (219µs+0s) by DBIx::Class::ResultSet::_rs_update_delete at line 1773 of DBIx/Class/ResultSet.pm, avg 12µs/call
sub delete {
1981 #my ($self, $source, @args) = @_;
198219258µs192.15s shift->_execute('delete', @_);
# spent 2.15s making 19 calls to DBIx::Class::Storage::DBI::_execute, avg 113ms/call
1983}
1984
1985# We were sent here because the $rs contains a complex search
1986# which will require a subquery to select the correct rows
1987# (i.e. joined or limited resultsets, or non-introspectable conditions)
1988#
1989# Generating a single PK column subquery is trivial and supported
1990# by all RDBMS. However if we have a multicolumn PK, things get ugly.
1991# Look at _multipk_update_delete()
1992sub _subq_update_delete {
1993 my $self = shift;
1994 my ($rs, $op, $values) = @_;
1995
1996 my $rsrc = $rs->result_source;
1997
1998 # quick check if we got a sane rs on our hands
1999 my @pcols = $rsrc->_pri_cols;
2000
2001 my $sel = $rs->_resolved_attrs->{select};
2002 $sel = [ $sel ] unless ref $sel eq 'ARRAY';
2003
2004 if (
2005 join ("\x00", map { join '.', $rs->{attrs}{alias}, $_ } sort @pcols)
2006 ne
2007 join ("\x00", sort @$sel )
2008 ) {
2009 $self->throw_exception (
2010 '_subq_update_delete can not be called on resultsets selecting columns other than the primary keys'
2011 );
2012 }
2013
2014 if (@pcols == 1) {
2015 return $self->$op (
2016 $rsrc,
2017 $op eq 'update' ? $values : (),
2018 { $pcols[0] => { -in => $rs->as_query } },
2019 );
2020 }
2021
2022 else {
2023 return $self->_multipk_update_delete (@_);
2024 }
2025}
2026
2027# ANSI SQL does not provide a reliable way to perform a multicol-PK
2028# resultset update/delete involving subqueries. So by default resort
2029# to simple (and inefficient) delete_all style per-row opearations,
2030# while allowing specific storages to override this with a faster
2031# implementation.
2032#
2033sub _multipk_update_delete {
2034 return shift->_per_row_update_delete (@_);
2035}
2036
2037# This is the default loop used to delete/update rows for multi PK
2038# resultsets, and used by mysql exclusively (because it can't do anything
2039# else).
2040#
2041# We do not use $row->$op style queries, because resultset update/delete
2042# is not expected to cascade (this is what delete_all/update_all is for).
2043#
2044# There should be no race conditions as the entire operation is rolled
2045# in a transaction.
2046#
2047sub _per_row_update_delete {
2048 my $self = shift;
2049 my ($rs, $op, $values) = @_;
2050
2051 my $rsrc = $rs->result_source;
2052 my @pcols = $rsrc->_pri_cols;
2053
2054 my $guard = $self->txn_scope_guard;
2055
2056 # emulate the return value of $sth->execute for non-selects
2057 my $row_cnt = '0E0';
2058
2059 my $subrs_cur = $rs->cursor;
2060 my @all_pk = $subrs_cur->all;
2061 for my $pks ( @all_pk) {
2062
2063 my $cond;
2064 for my $i (0.. $#pcols) {
2065 $cond->{$pcols[$i]} = $pks->[$i];
2066 }
2067
2068 $self->$op (
2069 $rsrc,
2070 $op eq 'update' ? $values : (),
2071 $cond,
2072 );
2073
2074 $row_cnt++;
2075 }
2076
2077 $guard->commit;
2078
2079 return $row_cnt;
2080}
2081
2082
# spent 9.96s (66.9ms+9.90) within DBIx::Class::Storage::DBI::_select which was called 6706 times, avg 1.49ms/call: # 3089 times (29.5ms+4.39s) by DBIx::Class::Storage::DBI::Cursor::_dbh_next at line 89 of DBIx/Class/Storage/DBI/Cursor.pm, avg 1.43ms/call # 2007 times (22.1ms+3.39s) by DBIx::Class::Storage::DBI::select_single at line 2218, avg 1.70ms/call # 1610 times (15.3ms+2.12s) by DBIx::Class::Storage::DBI::Cursor::_dbh_all at line 132 of DBIx/Class/Storage/DBI/Cursor.pm, avg 1.33ms/call
sub _select {
20831341260.7ms my $self = shift;
2084134129.90s $self->_execute($self->_select_args(@_));
# spent 8.89s making 6706 calls to DBIx::Class::Storage::DBI::_execute, avg 1.33ms/call # spent 1.00s making 6706 calls to DBIx::Class::Storage::DBI::_select_args, avg 149µs/call
2085}
2086
2087sub _select_args_to_query {
2088 my $self = shift;
2089
2090 # my ($op, $ident, $select, $cond, $rs_attrs, $rows, $offset)
2091 # = $self->_select_args($ident, $select, $cond, $attrs);
2092 my ($op, $ident, @args) =
2093 $self->_select_args(@_);
2094
2095 # my ($sql, $prepared_bind) = $self->_gen_sql_bind($op, $ident, [ $select, $cond, $rs_attrs, $rows, $offset ]);
2096 my ($sql, $prepared_bind) = $self->_gen_sql_bind($op, $ident, \@args);
2097 $prepared_bind ||= [];
2098
2099 return wantarray
2100 ? ($sql, $prepared_bind)
2101 : \[ "($sql)", @$prepared_bind ]
2102 ;
2103}
2104
2105
# spent 1.00s (257ms+745ms) within DBIx::Class::Storage::DBI::_select_args which was called 6706 times, avg 149µs/call: # 6706 times (257ms+745ms) by DBIx::Class::Storage::DBI::_select at line 2084, avg 149µs/call
sub _select_args {
210667065215ms my ($self, $ident, $select, $where, $attrs) = @_;
2107
2108670621.6ms my $sql_maker = $self->sql_maker;
# spent 21.6ms making 6706 calls to DBIx::Class::Storage::DBI::sql_maker, avg 3µs/call
21096706124ms my ($alias2source, $rs_alias) = $self->_resolve_ident_sources ($ident);
# spent 124ms making 6706 calls to DBIx::Class::Storage::DBIHacks::_resolve_ident_sources, avg 19µs/call
2110
2111 $attrs = {
2112 %$attrs,
2113 select => $select,
2114 from => $ident,
2115 where => $where,
2116 $rs_alias && $alias2source->{$rs_alias}
2117 ? ( _rsroot_rsrc => $alias2source->{$rs_alias} )
2118 : ()
2119 ,
2120 };
2121
2122 # Sanity check the attributes (SQLMaker does it too, but
2123 # in case of a software_limit we'll never reach there)
2124 if (defined $attrs->{offset}) {
2125 $self->throw_exception('A supplied offset attribute must be a non-negative integer')
2126 if ( $attrs->{offset} =~ /\D/ or $attrs->{offset} < 0 );
2127 }
2128
2129 if (defined $attrs->{rows}) {
2130522µs $self->throw_exception("The rows attribute must be a positive integer if present")
# spent 22µs making 5 calls to DBIx::Class::Storage::DBI::CORE:match, avg 4µs/call
2131 if ( $attrs->{rows} =~ /\D/ or $attrs->{rows} <= 0 );
2132 }
2133 elsif ($attrs->{offset}) {
2134 # MySQL actually recommends this approach. I cringe.
2135 $attrs->{rows} = $sql_maker->__max_int;
2136 }
2137
2138 my @limit;
2139
2140 # see if we need to tear the prefetch apart otherwise delegate the limiting to the
2141 # storage, unless software limit was requested
2142 if (
2143 #limited has_many
2144 ( $attrs->{rows} && keys %{$attrs->{collapse}} )
2145 ||
2146 # grouped prefetch (to satisfy group_by == select)
2147 ( $attrs->{group_by}
2148 &&
2149 @{$attrs->{group_by}}
2150 &&
2151 $attrs->{_prefetch_selector_range}
2152 )
2153 ) {
2154 ($ident, $select, $where, $attrs)
2155 = $self->_adjust_select_args_for_complex_prefetch ($ident, $select, $where, $attrs);
2156 }
2157 elsif (! $attrs->{software_limit} ) {
2158 push @limit, (
2159 $attrs->{rows} || (),
2160 $attrs->{offset} || (),
2161 );
2162 }
2163
2164 # try to simplify the joinmap further (prune unreferenced type-single joins)
21656706571ms $ident = $self->_prune_unused_joins ($ident, $select, $where, $attrs);
# spent 571ms making 6706 calls to DBIx::Class::Storage::DBIHacks::_prune_unused_joins, avg 85µs/call
2166
2167###
2168 # This would be the point to deflate anything found in $where
2169 # (and leave $attrs->{bind} intact). Problem is - inflators historically
2170 # expect a row object. And all we have is a resultsource (it is trivial
2171 # to extract deflator coderefs via $alias2source above).
2172 #
2173 # I don't see a way forward other than changing the way deflators are
2174 # invoked, and that's just bad...
2175###
2176
2177 return ('select', $ident, $select, $where, $attrs, @limit);
2178}
2179
2180# Returns a counting SELECT for a simple count
2181# query. Abstracted so that a storage could override
2182# this to { count => 'firstcol' } or whatever makes
2183# sense as a performance optimization
2184
# spent 7.59ms within DBIx::Class::Storage::DBI::_count_select which was called 1949 times, avg 4µs/call: # 1949 times (7.59ms+0s) by DBIx::Class::ResultSet::_count_rs at line 1494 of DBIx/Class/ResultSet.pm, avg 4µs/call
sub _count_select {
2185 #my ($self, $source, $rs_attrs) = @_;
218619498.58ms return { count => '*' };
2187}
2188
2189sub source_bind_attributes {
2190 shift->throw_exception(
2191 'source_bind_attributes() was never meant to be a callable public method - '
2192 .'please contact the DBIC dev-team and describe your use case so that a reasonable '
2193 .'solution can be provided'
2194 ."\nhttp://search.cpan.org/dist/DBIx-Class/lib/DBIx/Class.pm#GETTING_HELP/SUPPORT"
2195 );
2196}
2197
2198=head2 select
2199
2200=over 4
2201
2202=item Arguments: $ident, $select, $condition, $attrs
2203
2204=back
2205
2206Handle a SQL select statement.
2207
2208=cut
2209
2210
# spent 346ms (85.3+261) within DBIx::Class::Storage::DBI::select which was called 9400 times, avg 37µs/call: # 4699 times (58.8ms+261ms) by DBIx::Class::ResultSet::cursor at line 131, avg 68µs/call # 4699 times (26.6ms+140µs) by DBIx::Class::ResultSet::cursor at line 957 of DBIx/Class/ResultSet.pm, avg 6µs/call # 2 times (4µs+0s) by DBIx::Class::ResultSet::cursor at line 128, avg 2µs/call
sub select {
22111409756.5ms my $self = shift;
2212 my ($ident, $select, $condition, $attrs) = @_;
22139398261ms return $self->cursor_class->new($self, \@_, $attrs);
# spent 208ms making 4699 calls to DBIx::Class::Storage::cursor_class, avg 44µs/call # spent 52.6ms making 4699 calls to DBIx::Class::Storage::DBI::Cursor::new, avg 11µs/call
2214}
2215
2216
# spent 3.53s (89.0ms+3.44) within DBIx::Class::Storage::DBI::select_single which was called 4014 times, avg 880µs/call: # 2007 times (72.9ms+3.44s) by DBIx::Class::ResultSet::single at line 131, avg 1.75ms/call # 2007 times (16.2ms+0s) by DBIx::Class::ResultSet::single at line 1031 of DBIx/Class/ResultSet.pm, avg 8µs/call
sub select_single {
221714049108ms my $self = shift;
221820073.41s my ($rv, $sth, @bind) = $self->_select(@_);
# spent 3.41s making 2007 calls to DBIx::Class::Storage::DBI::_select, avg 1.70ms/call
2219200725.8ms my @row = $sth->fetchrow_array;
# spent 25.8ms making 2007 calls to DBI::st::fetchrow_array, avg 13µs/call
222015663.30ms my @nextrow = $sth->fetchrow_array if @row;
# spent 3.30ms making 1566 calls to DBI::st::fetchrow_array, avg 2µs/call
2221 if(@row && @nextrow) {
2222 carp "Query returned more than one row. SQL that returns multiple rows is DEPRECATED for ->find and ->single";
2223 }
2224 # Need to call finish() to work round broken DBDs
222520074.26ms $sth->finish();
# spent 4.26ms making 2007 calls to DBI::st::finish, avg 2µs/call
2226 return @row;
2227}
2228
2229=head2 sql_limit_dialect
2230
2231This is an accessor for the default SQL limit dialect used by a particular
2232storage driver. Can be overridden by supplying an explicit L</limit_dialect>
2233to L<DBIx::Class::Schema/connect>. For a list of available limit dialects
2234see L<DBIx::Class::SQLMaker::LimitDialects>.
2235
2236=head2 sth
2237
2238=over 4
2239
2240=item Arguments: $sql
2241
2242=back
2243
2244Returns a L<DBI> sth (statement handle) for the supplied SQL.
2245
2246=cut
2247
2248
# spent 472ms (89.7+382) within DBIx::Class::Storage::DBI::_dbh_sth which was called 8019 times, avg 59µs/call: # 8019 times (89.7ms+382ms) by DBIx::Class::Storage::DBI::dbh_do at line 780, avg 59µs/call
sub _dbh_sth {
224932072141ms my ($self, $dbh, $sql) = @_;
2250
2251 # 3 is the if_active parameter which avoids active sth re-use
2252146.9ms16044667ms my $sth = $self->disable_sth_caching
# spent 382ms making 8019 calls to DBI::db::prepare_cached, avg 48µs/call # spent 280ms making 8019 calls to DBD::_::db::prepare_cached, avg 35µs/call # spent 4.63ms making 2 calls to DBIx::Class::Storage::DBI::__ANON__[DBIx/Class/Storage/DBI.pm:1297], avg 2.31ms/call # spent 119µs making 1 call to DBIx::Class::Storage::DBI::disable_sth_caching # spent 11µs making 2 calls to DBI::common::FETCH, avg 6µs/call # spent 1µs making 1 call to DBIx::Class::Storage::DBI::SQLite::disable_sth_caching
2253 ? $dbh->prepare($sql)
2254 : $dbh->prepare_cached($sql, {}, 3);
2255
2256 # XXX You would think RaiseError would make this impossible,
2257 # but apparently that's not true :(
2258 $self->throw_exception(
2259 $dbh->errstr
2260 ||
2261 sprintf( "\$dbh->prepare() of '%s' through %s failed *silently* without "
2262 .'an exception and/or setting $dbh->errstr',
2263 length ($sql) > 20
2264 ? substr($sql, 0, 20) . '...'
2265 : $sql
2266 ,
2267 'DBD::' . $dbh->{Driver}{Name},
2268 )
2269 ) if !$sth;
2270
2271 $sth;
2272}
2273
2274sub sth {
2275 carp_unique 'sth was mistakenly marked/documented as public, stop calling it (will be removed before DBIC v0.09)';
2276 shift->_sth(@_);
2277}
2278
2279
# spent 652ms (56.7+595) within DBIx::Class::Storage::DBI::_sth which was called 8019 times, avg 81µs/call: # 8019 times (56.7ms+595ms) by DBIx::Class::Storage::DBI::_dbh_execute at line 1569, avg 81µs/call
sub _sth {
22801603845.5ms my ($self, $sql) = @_;
228180190s $self->dbh_do('_dbh_sth', $sql); # retry over disconnects
# spent 595ms making 8019 calls to DBIx::Class::Storage::DBI::dbh_do, avg 74µs/call, recursion: max depth 2, sum of overlapping time 595ms
2282}
2283
2284sub _dbh_columns_info_for {
2285 my ($self, $dbh, $table) = @_;
2286
2287 if ($dbh->can('column_info')) {
2288 my %result;
2289 my $caught;
2290 try {
2291 my ($schema,$tab) = $table =~ /^(.+?)\.(.+)$/ ? ($1,$2) : (undef,$table);
2292 my $sth = $dbh->column_info( undef,$schema, $tab, '%' );
2293 $sth->execute();
2294 while ( my $info = $sth->fetchrow_hashref() ){
2295 my %column_info;
2296 $column_info{data_type} = $info->{TYPE_NAME};
2297 $column_info{size} = $info->{COLUMN_SIZE};
2298 $column_info{is_nullable} = $info->{NULLABLE} ? 1 : 0;
2299 $column_info{default_value} = $info->{COLUMN_DEF};
2300 my $col_name = $info->{COLUMN_NAME};
2301 $col_name =~ s/^\"(.*)\"$/$1/;
2302
2303 $result{$col_name} = \%column_info;
2304 }
2305 } catch {
2306 $caught = 1;
2307 };
2308 return \%result if !$caught && scalar keys %result;
2309 }
2310
2311 my %result;
2312 my $sth = $dbh->prepare($self->sql_maker->select($table, undef, \'1 = 0'));
2313 $sth->execute;
2314 my @columns = @{$sth->{NAME_lc}};
2315 for my $i ( 0 .. $#columns ){
2316 my %column_info;
2317 $column_info{data_type} = $sth->{TYPE}->[$i];
2318 $column_info{size} = $sth->{PRECISION}->[$i];
2319 $column_info{is_nullable} = $sth->{NULLABLE}->[$i] ? 1 : 0;
2320
2321 if ($column_info{data_type} =~ m/^(.*?)\((.*?)\)$/) {
2322 $column_info{data_type} = $1;
2323 $column_info{size} = $2;
2324 }
2325
2326 $result{$columns[$i]} = \%column_info;
2327 }
2328 $sth->finish;
2329
2330 foreach my $col (keys %result) {
2331 my $colinfo = $result{$col};
2332 my $type_num = $colinfo->{data_type};
2333 my $type_name;
2334 if(defined $type_num && $dbh->can('type_info')) {
2335 my $type_info = $dbh->type_info($type_num);
2336 $type_name = $type_info->{TYPE_NAME} if $type_info;
2337 $colinfo->{data_type} = $type_name if $type_name;
2338 }
2339 }
2340
2341 return \%result;
2342}
2343
2344sub columns_info_for {
2345 my ($self, $table) = @_;
2346 $self->_dbh_columns_info_for ($self->_get_dbh, $table);
2347}
2348
2349=head2 last_insert_id
2350
2351Return the row id of the last insert.
2352
2353=cut
2354
2355
# spent 19.8ms (5.42+14.3) within DBIx::Class::Storage::DBI::_dbh_last_insert_id which was called 296 times, avg 67µs/call: # 296 times (5.42ms+14.3ms) by DBIx::Class::Storage::DBI::last_insert_id at line 2368, avg 67µs/call
sub _dbh_last_insert_id {
23568885.84ms my ($self, $dbh, $source, $col) = @_;
2357
23582966.63ms59316.4ms
# spent 5.91ms (3.85+2.06) within DBIx::Class::Storage::DBI::__ANON__[/2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/site_perl/5.12.3/DBIx/Class/Storage/DBI.pm:2358] which was called 296 times, avg 20µs/call: # 296 times (3.85ms+2.06ms) by Try::Tiny::try at line 71 of Try/Tiny.pm, avg 20µs/call
my $id = try { $dbh->last_insert_id (undef, undef, $source->name, $col) };
# spent 14.3ms making 296 calls to Try::Tiny::try, avg 48µs/call # spent 2.05ms making 296 calls to DBI::db::last_insert_id, avg 7µs/call # spent 4µs making 1 call to DBIx::Class::ResultSource::Table::name
2359
2360 return $id if defined $id;
2361
2362 my $class = ref $self;
2363 $self->throw_exception ("No storage specific _dbh_last_insert_id() method implemented in $class, and the generic DBI::last_insert_id() failed");
2364}
2365
2366
# spent 23.5ms (3.72+19.8) within DBIx::Class::Storage::DBI::last_insert_id which was called 296 times, avg 79µs/call: # 296 times (3.72ms+19.8ms) by DBIx::Class::Storage::DBI::insert at line 1691, avg 79µs/call
sub last_insert_id {
23675923.66ms my $self = shift;
236829719.8ms $self->_dbh_last_insert_id ($self->_dbh, @_);
# spent 19.8ms making 296 calls to DBIx::Class::Storage::DBI::_dbh_last_insert_id, avg 67µs/call # spent 4µs making 1 call to DBIx::Class::Storage::DBI::_dbh
2369}
2370
2371=head2 _native_data_type
2372
2373=over 4
2374
2375=item Arguments: $type_name
2376
2377=back
2378
2379This API is B<EXPERIMENTAL>, will almost definitely change in the future, and
2380currently only used by L<::AutoCast|DBIx::Class::Storage::DBI::AutoCast> and
2381L<::Sybase::ASE|DBIx::Class::Storage::DBI::Sybase::ASE>.
2382
2383The default implementation returns C<undef>, implement in your Storage driver if
2384you need this functionality.
2385
2386Should map types from other databases to the native RDBMS type, for example
2387C<VARCHAR2> to C<VARCHAR>.
2388
2389Types with modifiers should map to the underlying data type. For example,
2390C<INTEGER AUTO_INCREMENT> should become C<INTEGER>.
2391
2392Composite types should map to the container type, for example
2393C<ENUM(foo,bar,baz)> becomes C<ENUM>.
2394
2395=cut
2396
2397sub _native_data_type {
2398 #my ($self, $data_type) = @_;
2399 return undef
2400}
2401
2402# Check if placeholders are supported at all
2403sub _determine_supports_placeholders {
2404 my $self = shift;
2405 my $dbh = $self->_get_dbh;
2406
2407 # some drivers provide a $dbh attribute (e.g. Sybase and $dbh->{syb_dynamic_supported})
2408 # but it is inaccurate more often than not
2409 return try {
2410 local $dbh->{PrintError} = 0;
2411 local $dbh->{RaiseError} = 1;
2412 $dbh->do('select ?', {}, 1);
2413 1;
2414 }
2415 catch {
2416 0;
2417 };
2418}
2419
2420# Check if placeholders bound to non-string types throw exceptions
2421#
2422sub _determine_supports_typeless_placeholders {
2423 my $self = shift;
2424 my $dbh = $self->_get_dbh;
2425
2426 return try {
2427 local $dbh->{PrintError} = 0;
2428 local $dbh->{RaiseError} = 1;
2429 # this specifically tests a bind that is NOT a string
2430 $dbh->do('select 1 where 1 = ?', {}, 1);
2431 1;
2432 }
2433 catch {
2434 0;
2435 };
2436}
2437
2438=head2 sqlt_type
2439
2440Returns the database driver name.
2441
2442=cut
2443
2444
# spent 110µs (60+50) within DBIx::Class::Storage::DBI::sqlt_type which was called 8 times, avg 14µs/call: # 4 times (50µs+50µs) by DBIx::Class::Storage::DBI::deployment_statements at line 131, avg 25µs/call # 4 times (10µs+0s) by DBIx::Class::Storage::DBI::deployment_statements at line 2701, avg 2µs/call
sub sqlt_type {
2445470µs1250µs shift->_get_dbh->{Driver}->{Name};
# spent 31µs making 4 calls to DBIx::Class::Storage::DBI::_get_dbh, avg 8µs/call # spent 19µs making 8 calls to DBI::common::FETCH, avg 2µs/call
2446}
2447
2448=head2 bind_attribute_by_data_type
2449
2450Given a datatype from column info, returns a database specific bind
2451attribute for C<< $dbh->bind_param($val,$attribute) >> or nothing if we will
2452let the database planner just handle it.
2453
2454Generally only needed for special case column types, like bytea in postgres.
2455
2456=cut
2457
2458sub bind_attribute_by_data_type {
2459 return;
2460}
2461
2462=head2 is_datatype_numeric
2463
2464Given a datatype from column_info, returns a boolean value indicating if
2465the current RDBMS considers it a numeric value. This controls how
2466L<DBIx::Class::Row/set_column> decides whether to mark the column as
2467dirty - when the datatype is deemed numeric a C<< != >> comparison will
2468be performed instead of the usual C<eq>.
2469
2470=cut
2471
2472
# spent 42µs (26+16) within DBIx::Class::Storage::DBI::is_datatype_numeric which was called 3 times, avg 14µs/call: # 3 times (26µs+16µs) by DBIx::Class::Row::_is_column_numeric at line 794 of DBIx/Class/Row.pm, avg 14µs/call
sub is_datatype_numeric {
2473 #my ($self, $dt) = @_;
2474
2475645µs return 0 unless $_[1];
2476
2477316µs $_[1] =~ /^ (?:
# spent 16µs making 3 calls to DBIx::Class::Storage::DBI::CORE:match, avg 5µs/call
2478 numeric | int(?:eger)? | (?:tiny|small|medium|big)int | dec(?:imal)? | real | float | double (?: \s+ precision)? | (?:big)?serial
2479 ) $/ix;
2480}
2481
2482
2483=head2 create_ddl_dir
2484
2485=over 4
2486
2487=item Arguments: $schema \@databases, $version, $directory, $preversion, \%sqlt_args
2488
2489=back
2490
2491Creates a SQL file based on the Schema, for each of the specified
2492database engines in C<\@databases> in the given directory.
2493(note: specify L<SQL::Translator> names, not L<DBI> driver names).
2494
2495Given a previous version number, this will also create a file containing
2496the ALTER TABLE statements to transform the previous schema into the
2497current one. Note that these statements may contain C<DROP TABLE> or
2498C<DROP COLUMN> statements that can potentially destroy data.
2499
2500The file names are created using the C<ddl_filename> method below, please
2501override this method in your schema if you would like a different file
2502name format. For the ALTER file, the same format is used, replacing
2503$version in the name with "$preversion-$version".
2504
2505See L<SQL::Translator/METHODS> for a list of values for C<\%sqlt_args>.
2506The most common value for this would be C<< { add_drop_table => 1 } >>
2507to have the SQL produced include a C<DROP TABLE> statement for each table
2508created. For quoting purposes supply C<quote_table_names> and
2509C<quote_field_names>.
2510
2511If no arguments are passed, then the following default values are assumed:
2512
2513=over 4
2514
2515=item databases - ['MySQL', 'SQLite', 'PostgreSQL']
2516
2517=item version - $schema->schema_version
2518
2519=item directory - './'
2520
2521=item preversion - <none>
2522
2523=back
2524
2525By default, C<\%sqlt_args> will have
2526
2527 { add_drop_table => 1, ignore_constraint_names => 1, ignore_index_names => 1 }
2528
2529merged with the hash passed in. To disable any of those features, pass in a
2530hashref like the following
2531
2532 { ignore_constraint_names => 0, # ... other options }
2533
2534
2535WARNING: You are strongly advised to check all SQL files created, before applying
2536them.
2537
2538=cut
2539
2540sub create_ddl_dir {
2541 my ($self, $schema, $databases, $version, $dir, $preversion, $sqltargs) = @_;
2542
2543 unless ($dir) {
2544 carp "No directory given, using ./\n";
2545 $dir = './';
2546 } else {
2547 -d $dir
2548 or
2549 (require File::Path and File::Path::make_path ("$dir")) # make_path does not like objects (i.e. Path::Class::Dir)
2550 or
2551 $self->throw_exception(
2552 "Failed to create '$dir': " . ($! || $@ || 'error unknown')
2553 );
2554 }
2555
2556 $self->throw_exception ("Directory '$dir' does not exist\n") unless(-d $dir);
2557
2558 $databases ||= ['MySQL', 'SQLite', 'PostgreSQL'];
2559 $databases = [ $databases ] if(ref($databases) ne 'ARRAY');
2560
2561 my $schema_version = $schema->schema_version || '1.x';
2562 $version ||= $schema_version;
2563
2564 $sqltargs = {
2565 add_drop_table => 1,
2566 ignore_constraint_names => 1,
2567 ignore_index_names => 1,
2568 %{$sqltargs || {}}
2569 };
2570
2571 unless (DBIx::Class::Optional::Dependencies->req_ok_for ('deploy')) {
2572 $self->throw_exception("Can't create a ddl file without " . DBIx::Class::Optional::Dependencies->req_missing_for ('deploy') );
2573 }
2574
2575 my $sqlt = SQL::Translator->new( $sqltargs );
2576
2577 $sqlt->parser('SQL::Translator::Parser::DBIx::Class');
2578 my $sqlt_schema = $sqlt->translate({ data => $schema })
2579 or $self->throw_exception ($sqlt->error);
2580
2581 foreach my $db (@$databases) {
2582 $sqlt->reset();
2583 $sqlt->{schema} = $sqlt_schema;
2584 $sqlt->producer($db);
2585
2586 my $file;
2587 my $filename = $schema->ddl_filename($db, $version, $dir);
2588 if (-e $filename && ($version eq $schema_version )) {
2589 # if we are dumping the current version, overwrite the DDL
2590 carp "Overwriting existing DDL file - $filename";
2591 unlink($filename);
2592 }
2593
2594 my $output = $sqlt->translate;
2595 if(!$output) {
2596 carp("Failed to translate to $db, skipping. (" . $sqlt->error . ")");
2597 next;
2598 }
2599 if(!open($file, ">$filename")) {
2600 $self->throw_exception("Can't open $filename for writing ($!)");
2601 next;
2602 }
2603 print $file $output;
2604 close($file);
2605
2606 next unless ($preversion);
2607
2608 require SQL::Translator::Diff;
2609
2610 my $prefilename = $schema->ddl_filename($db, $preversion, $dir);
2611 if(!-e $prefilename) {
2612 carp("No previous schema file found ($prefilename)");
2613 next;
2614 }
2615
2616 my $difffile = $schema->ddl_filename($db, $version, $dir, $preversion);
2617 if(-e $difffile) {
2618 carp("Overwriting existing diff file - $difffile");
2619 unlink($difffile);
2620 }
2621
2622 my $source_schema;
2623 {
2624 my $t = SQL::Translator->new($sqltargs);
2625 $t->debug( 0 );
2626 $t->trace( 0 );
2627
2628 $t->parser( $db )
2629 or $self->throw_exception ($t->error);
2630
2631 my $out = $t->translate( $prefilename )
2632 or $self->throw_exception ($t->error);
2633
2634 $source_schema = $t->schema;
2635
2636 $source_schema->name( $prefilename )
2637 unless ( $source_schema->name );
2638 }
2639
2640 # The "new" style of producers have sane normalization and can support
2641 # diffing a SQL file against a DBIC->SQLT schema. Old style ones don't
2642 # And we have to diff parsed SQL against parsed SQL.
2643 my $dest_schema = $sqlt_schema;
2644
2645 unless ( "SQL::Translator::Producer::$db"->can('preprocess_schema') ) {
2646 my $t = SQL::Translator->new($sqltargs);
2647 $t->debug( 0 );
2648 $t->trace( 0 );
2649
2650 $t->parser( $db )
2651 or $self->throw_exception ($t->error);
2652
2653 my $out = $t->translate( $filename )
2654 or $self->throw_exception ($t->error);
2655
2656 $dest_schema = $t->schema;
2657
2658 $dest_schema->name( $filename )
2659 unless $dest_schema->name;
2660 }
2661
2662 my $diff = SQL::Translator::Diff::schema_diff($source_schema, $db,
2663 $dest_schema, $db,
2664 $sqltargs
2665 );
2666 if(!open $file, ">$difffile") {
2667 $self->throw_exception("Can't write to $difffile ($!)");
2668 next;
2669 }
2670 print $file $diff;
2671 close($file);
2672 }
2673}
2674
2675=head2 deployment_statements
2676
2677=over 4
2678
2679=item Arguments: $schema, $type, $version, $directory, $sqlt_args
2680
2681=back
2682
2683Returns the statements used by L</deploy> and L<DBIx::Class::Schema/deploy>.
2684
2685The L<SQL::Translator> (not L<DBI>) database driver name can be explicitly
2686provided in C<$type>, otherwise the result of L</sqlt_type> is used as default.
2687
2688C<$directory> is used to return statements from files in a previously created
2689L</create_ddl_dir> directory and is optional. The filenames are constructed
2690from L<DBIx::Class::Schema/ddl_filename>, the schema name and the C<$version>.
2691
2692If no C<$directory> is specified then the statements are constructed on the
2693fly using L<SQL::Translator> and C<$version> is ignored.
2694
2695See L<SQL::Translator/METHODS> for a list of values for C<$sqlt_args>.
2696
2697=cut
2698
2699
# spent 238ms (324µs+237) within DBIx::Class::Storage::DBI::deployment_statements which was called 10 times, avg 23.8ms/call: # 4 times (264µs+235ms) by DBIx::Class::Storage::DBI::SQLite::deployment_statements at line 131, avg 58.8ms/call # 4 times (13µs+0s) by DBIx::Class::Storage::DBI::SQLite::deployment_statements at line 28 of mro.pm, avg 3µs/call # 2 times (48µs+2.26ms) by DBIx::Class::Schema::deployment_statements at line 1144 of DBIx/Class/Schema.pm, avg 1.15ms/call
sub deployment_statements {
270052272µs my ($self, $schema, $type, $version, $dir, $sqltargs) = @_;
2701410µs $type ||= $self->sqlt_type;
# spent 10µs making 4 calls to DBIx::Class::Storage::DBI::sqlt_type, avg 2µs/call
2702429µs $version ||= $schema->schema_version || '1.x';
# spent 29µs making 4 calls to DBIx::Class::Schema::schema_version, avg 7µs/call
2703 $dir ||= './';
27044279µs my $filename = $schema->ddl_filename($type, $version, $dir);
# spent 279µs making 4 calls to DBIx::Class::Schema::ddl_filename, avg 70µs/call
2705433µs if(-f $filename)
# spent 33µs making 4 calls to DBIx::Class::Storage::DBI::CORE:ftfile, avg 8µs/call
2706 {
2707 # FIXME replace this block when a proper sane sql parser is available
2708 my $file;
2709 open($file, "<$filename")
2710 or $self->throw_exception("Can't open $filename ($!)");
2711 my @rows = <$file>;
2712 close($file);
2713 return join('', @rows);
2714 }
2715
2716431.0ms unless (DBIx::Class::Optional::Dependencies->req_ok_for ('deploy') ) {
# spent 31.0ms making 4 calls to DBIx::Class::Optional::Dependencies::req_ok_for, avg 7.76ms/call
2717 $self->throw_exception("Can't deploy without a ddl_dir or " . DBIx::Class::Optional::Dependencies->req_missing_for ('deploy') );
2718 }
2719
2720 # sources needs to be a parser arg, but for simplicty allow at top level
2721 # coming in
2722 $sqltargs->{parser_args}{sources} = delete $sqltargs->{sources}
2723 if exists $sqltargs->{sources};
2724
272546.99ms my $tr = SQL::Translator->new(
# spent 6.99ms making 4 calls to Class::Base::new, avg 1.75ms/call
2726 producer => "SQL::Translator::Producer::${type}",
2727 %$sqltargs,
2728 parser => 'SQL::Translator::Parser::DBIx::Class',
2729 data => $schema,
2730 );
2731
2732 my @ret;
27334197ms if (wantarray) {
# spent 197ms making 4 calls to SQL::Translator::translate, avg 49.1ms/call
2734 @ret = $tr->translate;
2735 }
2736 else {
2737 $ret[0] = $tr->translate;
2738 }
2739
2740 $self->throw_exception( 'Unable to produce deployment statements: ' . $tr->error)
2741 unless (@ret && defined $ret[0]);
2742
2743 return wantarray ? @ret : $ret[0];
2744}
2745
2746# FIXME deploy() currently does not accurately report sql errors
2747# Will always return true while errors are warned
2748
# spent 8.22s (1.08ms+8.21) within DBIx::Class::Storage::DBI::deploy which was called 4 times, avg 2.05s/call: # 4 times (1.08ms+8.21s) by DBIx::Class::Schema::deploy at line 1118 of DBIx/Class/Schema.pm, avg 2.05s/call
sub deploy {
274995753µs my ($self, $schema, $type, $sqltargs, $dir) = @_;
2750
# spent 7.96s (7.38ms+7.95) within DBIx::Class::Storage::DBI::__ANON__[/2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/site_perl/5.12.3/DBIx/Class/Storage/DBI.pm:2767] which was called 79 times, avg 101ms/call: # 79 times (7.38ms+7.95s) by DBIx::Class::Storage::DBI::deploy at line 2771, avg 101ms/call
my $deploy = sub {
27516758.08ms my $line = shift;
2752 return if(!$line);
275379430µs return if($line =~ /^--/);
# spent 430µs making 79 calls to DBIx::Class::Storage::DBI::CORE:match, avg 5µs/call
2754 # next if($line =~ /^DROP/m);
275579194µs return if($line =~ /^BEGIN TRANSACTION/m);
# spent 194µs making 79 calls to DBIx::Class::Storage::DBI::CORE:match, avg 2µs/call
275675156µs return if($line =~ /^COMMIT/m);
# spent 156µs making 75 calls to DBIx::Class::Storage::DBI::CORE:match, avg 2µs/call
275771695µs return if $line =~ /^\s+$/; # skip whitespace only
# spent 695µs making 71 calls to DBIx::Class::Storage::DBI::CORE:match, avg 10µs/call
2758711.32ms $self->_query_start($line);
# spent 1.32ms making 71 calls to DBIx::Class::Storage::DBI::_query_start, avg 19µs/call
2759
# spent 7.94s (1.32ms+7.94) within DBIx::Class::Storage::DBI::__ANON__[/2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/site_perl/5.12.3/DBIx/Class/Storage/DBI.pm:2763] which was called 71 times, avg 112ms/call: # 71 times (1.32ms+7.94s) by Try::Tiny::try at line 76 of Try/Tiny.pm, avg 112ms/call
try {
2760 # do a dbh_do cycle here, as we need some error checking in
2761 # place (even though we will ignore errors)
27621423.88ms21323.8s
# spent 7.93s (1.23ms+7.93) within DBIx::Class::Storage::DBI::__ANON__[/2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/site_perl/5.12.3/DBIx/Class/Storage/DBI.pm:2762] which was called 71 times, avg 112ms/call: # 71 times (1.23ms+7.93s) by DBIx::Class::Storage::DBI::__ANON__[/2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/site_perl/5.12.3/DBIx/Class/Storage/DBI.pm:790] at line 789, avg 112ms/call
$self->dbh_do (sub { $_[1]->do($line) });
# spent 7.94s making 71 calls to DBIx::Class::Storage::DBI::dbh_do, avg 112ms/call # spent 7.93s making 71 calls to DBI::db::do, avg 112ms/call # spent 7.93s making 71 calls to DBD::SQLite::db::do, avg 112ms/call
2763 } catch {
2764 carp qq{$_ (running "${line}")};
27651427.95s };
# spent 7.95s making 71 calls to Try::Tiny::try, avg 112ms/call # spent 1.13ms making 71 calls to Try::Tiny::catch, avg 16µs/call
2766711.22ms $self->_query_end($line);
# spent 1.22ms making 71 calls to DBIx::Class::Storage::DBI::_query_end, avg 17µs/call
2767 };
27684256ms my @statements = $schema->deployment_statements($type, undef, $dir, { %{ $sqltargs || {} }, no_comments => 1 } );
# spent 256ms making 4 calls to DBIx::Class::Schema::deployment_statements, avg 64.0ms/call
2769 if (@statements > 1) {
2770 foreach my $statement (@statements) {
2771797.96s $deploy->( $statement );
# spent 7.96s making 79 calls to DBIx::Class::Storage::DBI::__ANON__[DBIx/Class/Storage/DBI.pm:2767], avg 101ms/call
2772 }
2773 }
2774 elsif (@statements == 1) {
2775 # split on single line comments and end of statements
2776 foreach my $line ( split(/\s*--.*\n|;\n/, $statements[0])) {
2777 $deploy->( $line );
2778 }
2779 }
2780}
2781
2782=head2 datetime_parser
2783
2784Returns the datetime parser class
2785
2786=cut
2787
2788
# spent 12.3ms (1.53+10.8) within DBIx::Class::Storage::DBI::datetime_parser which was called 294 times, avg 42µs/call: # 147 times (559µs+10.8ms) by DBIx::Class::InflateColumn::DateTime::_datetime_parser at line 221 of DBIx/Class/InflateColumn/DateTime.pm, avg 77µs/call # 147 times (967µs+0s) by Tapper::MCP::Scheduler::Controller::mark_job_as_running at line 135 of lib/Tapper/MCP/Scheduler/Controller.pm, avg 7µs/call
sub datetime_parser {
27895882.07ms my $self = shift;
279013µs return $self->{datetime_parser} ||= do {
2791 $self->build_datetime_parser(@_);
2792 };
2793}
2794
2795=head2 datetime_parser_type
2796
2797Defines the datetime parser class - currently defaults to L<DateTime::Format::MySQL>
2798
2799=head2 build_datetime_parser
2800
2801See L</datetime_parser>
2802
2803=cut
2804
2805
# spent 10.8ms (15µs+10.8) within DBIx::Class::Storage::DBI::build_datetime_parser which was called 2 times, avg 5.38ms/call: # once (12µs+10.8ms) by DBIx::Class::Storage::DBI::datetime_parser at line 131 # once (3µs+0s) by DBIx::Class::Storage::DBI::datetime_parser at line 2790
sub build_datetime_parser {
280637µs my $self = shift;
280712µs my $type = $self->datetime_parser_type(@_);
2808 return $type;
2809}
2810
2811
2812=head2 is_replicating
2813
2814A boolean that reports if a particular L<DBIx::Class::Storage::DBI> is set to
2815replicate from a master database. Default is undef, which is the result
2816returned by databases that don't support replication.
2817
2818=cut
2819
2820sub is_replicating {
2821 return;
2822
2823}
2824
2825=head2 lag_behind_master
2826
2827Returns a number that represents a certain amount of lag behind a master db
2828when a given storage is replicating. The number is database dependent, but
2829starts at zero and increases with the amount of lag. Default in undef
2830
2831=cut
2832
2833sub lag_behind_master {
2834 return;
2835}
2836
2837=head2 relname_to_table_alias
2838
2839=over 4
2840
2841=item Arguments: $relname, $join_count
2842
2843=back
2844
2845L<DBIx::Class> uses L<DBIx::Class::Relationship> names as table aliases in
2846queries.
2847
2848This hook is to allow specific L<DBIx::Class::Storage> drivers to change the
2849way these aliases are named.
2850
2851The default behavior is C<< "$relname_$join_count" if $join_count > 1 >>,
2852otherwise C<"$relname">.
2853
2854=cut
2855
2856
# spent 1.03ms within DBIx::Class::Storage::DBI::relname_to_table_alias which was called 294 times, avg 3µs/call: # 147 times (681µs+0s) by DBIx::Class::ResultSource::_resolve_join at line 1504 of DBIx/Class/ResultSource.pm, avg 5µs/call # 147 times (345µs+0s) by DBIx::Class::ResultSet::related_resultset at line 2874 of DBIx/Class/ResultSet.pm, avg 2µs/call
sub relname_to_table_alias {
28578821.21ms my ($self, $relname, $join_count) = @_;
2858
2859 my $alias = ($join_count && $join_count > 1 ?
2860 join('_', $relname, $join_count) : $relname);
2861
2862 return $alias;
2863}
2864
2865# The size in bytes to use for DBI's ->bind_param_inout, this is the generic
2866# version and it may be necessary to amend or override it for a specific storage
2867# if such binds are necessary.
2868sub _max_column_bytesize {
2869 my ($self, $attr) = @_;
2870
2871 my $max_size;
2872
2873 if ($attr->{sqlt_datatype}) {
2874 my $data_type = lc($attr->{sqlt_datatype});
2875
2876 if ($attr->{sqlt_size}) {
2877
2878 # String/sized-binary types
2879 if ($data_type =~ /^(?:
2880 l? (?:var)? char(?:acter)? (?:\s*varying)?
2881 |
2882 (?:var)? binary (?:\s*varying)?
2883 |
2884 raw
2885 )\b/x
2886 ) {
2887 $max_size = $attr->{sqlt_size};
2888 }
2889 # Other charset/unicode types, assume scale of 4
2890 elsif ($data_type =~ /^(?:
2891 national \s* character (?:\s*varying)?
2892 |
2893 nchar
2894 |
2895 univarchar
2896 |
2897 nvarchar
2898 )\b/x
2899 ) {
2900 $max_size = $attr->{sqlt_size} * 4;
2901 }
2902 }
2903
2904 if (!$max_size and !$self->_is_lob_type($data_type)) {
2905 $max_size = 100 # for all other (numeric?) datatypes
2906 }
2907 }
2908
2909 $max_size || $self->_dbic_connect_attributes->{LongReadLen} || $self->_get_dbh->{LongReadLen} || 8000;
2910}
2911
2912# Determine if a data_type is some type of BLOB
2913sub _is_lob_type {
2914 my ($self, $data_type) = @_;
2915 $data_type && ($data_type =~ /lob|bfile|text|image|bytea|memo/i
2916 || $data_type =~ /^long(?:\s+(?:raw|bit\s*varying|varbit|binary
2917 |varchar|character\s*varying|nvarchar
2918 |national\s*character\s*varying))?\z/xi);
2919}
2920
2921sub _is_binary_lob_type {
2922 my ($self, $data_type) = @_;
2923 $data_type && ($data_type =~ /blob|bfile|image|bytea/i
2924 || $data_type =~ /^long(?:\s+(?:raw|bit\s*varying|varbit|binary))?\z/xi);
2925}
2926
2927sub _is_text_lob_type {
2928 my ($self, $data_type) = @_;
2929 $data_type && ($data_type =~ /^(?:clob|memo)\z/i
2930 || $data_type =~ /^long(?:\s+(?:varchar|character\s*varying|nvarchar
2931 |national\s*character\s*varying))\z/xi);
2932}
2933
2934129µs1;
2935
2936=head1 USAGE NOTES
2937
2938=head2 DBIx::Class and AutoCommit
2939
2940DBIx::Class can do some wonderful magic with handling exceptions,
2941disconnections, and transactions when you use C<< AutoCommit => 1 >>
2942(the default) combined with L<txn_do|DBIx::Class::Storage/txn_do> for
2943transaction support.
2944
2945If you set C<< AutoCommit => 0 >> in your connect info, then you are always
2946in an assumed transaction between commits, and you're telling us you'd
2947like to manage that manually. A lot of the magic protections offered by
2948this module will go away. We can't protect you from exceptions due to database
2949disconnects because we don't know anything about how to restart your
2950transactions. You're on your own for handling all sorts of exceptional
2951cases if you choose the C<< AutoCommit => 0 >> path, just as you would
2952be with raw DBI.
2953
2954
2955=head1 AUTHORS
2956
2957Matt S. Trout <mst@shadowcatsystems.co.uk>
2958
2959Andy Grundman <andy@hybridized.org>
2960
2961=head1 LICENSE
2962
2963You may distribute this code under the same terms as Perl itself.
2964
2965160µs1758µs=cut
 
# spent 33µs within DBIx::Class::Storage::DBI::CORE:ftfile which was called 4 times, avg 8µs/call: # 4 times (33µs+0s) by DBIx::Class::Storage::DBI::deployment_statements at line 2705, avg 8µs/call
sub DBIx::Class::Storage::DBI::CORE:ftfile; # opcode
# spent 1.59ms within DBIx::Class::Storage::DBI::CORE:match which was called 322 times, avg 5µs/call: # 79 times (430µs+0s) by DBIx::Class::Storage::DBI::__ANON__[/2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/site_perl/5.12.3/DBIx/Class/Storage/DBI.pm:2767] at line 2753, avg 5µs/call # 79 times (194µs+0s) by DBIx::Class::Storage::DBI::__ANON__[/2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/site_perl/5.12.3/DBIx/Class/Storage/DBI.pm:2767] at line 2755, avg 2µs/call # 75 times (156µs+0s) by DBIx::Class::Storage::DBI::__ANON__[/2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/site_perl/5.12.3/DBIx/Class/Storage/DBI.pm:2767] at line 2756, avg 2µs/call # 71 times (695µs+0s) by DBIx::Class::Storage::DBI::__ANON__[/2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/site_perl/5.12.3/DBIx/Class/Storage/DBI.pm:2767] at line 2757, avg 10µs/call # 6 times (56µs+0s) by DBIx::Class::Storage::DBI::_determine_driver at line 1143, avg 9µs/call # 5 times (22µs+0s) by DBIx::Class::Storage::DBI::_select_args at line 2130, avg 4µs/call # 4 times (21µs+0s) by DBIx::Class::Storage::DBI::_server_info at line 1083, avg 5µs/call # 3 times (16µs+0s) by DBIx::Class::Storage::DBI::is_datatype_numeric at line 2477, avg 5µs/call
sub DBIx::Class::Storage::DBI::CORE:match; # opcode
# spent 2.94ms within DBIx::Class::Storage::DBI::CORE:subst which was called 296 times, avg 10µs/call: # 296 times (2.94ms+0s) by DBIx::Class::Storage::DBI::get_use_dbms_capability at line 1043, avg 10µs/call
sub DBIx::Class::Storage::DBI::CORE:subst; # opcode
# spent 4µs within DBIx::Class::Storage::DBI::schema which was called 4 times, avg 900ns/call: # 2 times (2µs+0s) by DBIx::Class::Storage::throw_exception at line 111 of DBIx/Class/Storage.pm, avg 1µs/call # once (900ns+0s) by DBIx::Class::Storage::set_schema at line 73 of DBIx/Class/Storage.pm # once (600ns+0s) by DBIx::Class::Storage::set_schema at line 781 of Class/Accessor/Grouped.pm
sub DBIx::Class::Storage::DBI::schema; # xsub