Profile of DBIx/Class/Storage/DBI.pm

← 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:24:02 2012

Filename | /2home/ss5/perl5/perlbrew/perls/perl-5.12.3/lib/site_perl/5.12.3/DBIx/Class/Storage/DBI.pm
Statements | Executed 1036527 statements in 155s

Subroutines
Calls | P | F | Exclusive Time | Inclusive Time | Subroutine
--- | --- | --- | --- | --- | ---
8019 | 1 | 1 | 460ms | 8.62s | DBIx::Class::Storage::DBI::::_gen_sql_bindDBIx::Class::Storage::DBI::_gen_sql_bind
22286 | 6 | 2 | 376ms | 132s | DBIx::Class::Storage::DBI::::dbh_doDBIx::Class::Storage::DBI::dbh_do (recurses: max depth 2, inclusive time 1.61s)
8019 | 2 | 1 | 349ms | 118s | DBIx::Class::Storage::DBI::::_dbh_executeDBIx::Class::Storage::DBI::_dbh_execute
6706 | 1 | 1 | 257ms | 1.00s | DBIx::Class::Storage::DBI::::_select_argsDBIx::Class::Storage::DBI::_select_args
8019 | 4 | 1 | 159ms | 127s | DBIx::Class::Storage::DBI::::_executeDBIx::Class::Storage::DBI::_execute
22588 | 4 | 1 | 154ms | 254ms | DBIx::Class::Storage::DBI::::_get_dbhDBIx::Class::Storage::DBI::_get_dbh
8019 | 1 | 1 | 142ms | 142ms | DBIx::Class::Storage::DBI::::_dbi_attrs_for_bindDBIx::Class::Storage::DBI::_dbi_attrs_for_bind
11153 | 1 | 1 | 123ms | 2.29s | DBIx::Class::Storage::DBI::::__ANON__[:1443]DBIx::Class::Storage::DBI::__ANON__[:1443]
33656 | 6 | 2 | 118ms | 133ms | DBIx::Class::Storage::DBI::::sql_makerDBIx::Class::Storage::DBI::sql_maker
8019 | 1 | 1 | 89.7ms | 472ms | DBIx::Class::Storage::DBI::::_dbh_sthDBIx::Class::Storage::DBI::_dbh_sth
4014 | 2 | 2 | 89.0ms | 3.53s | DBIx::Class::Storage::DBI::::select_singleDBIx::Class::Storage::DBI::select_single
9400 | 3 | 2 | 85.3ms | 346ms | DBIx::Class::Storage::DBI::::selectDBIx::Class::Storage::DBI::select
22890 | 4 | 1 | 79.8ms | 80.0ms | DBIx::Class::Storage::DBI::::_verify_pidDBIx::Class::Storage::DBI::_verify_pid
898 | 2 | 2 | 78.2ms | 36.2s | DBIx::Class::Storage::DBI::::insertDBIx::Class::Storage::DBI::insert
14004 | 3 | 3 | 74.5ms | 288ms | DBIx::Class::Storage::DBI::::get_use_dbms_capabilityDBIx::Class::Storage::DBI::get_use_dbms_capability
6706 | 3 | 2 | 66.9ms | 9.96s | DBIx::Class::Storage::DBI::::_selectDBIx::Class::Storage::DBI::_select
9274 | 2 | 1 | 65.1ms | 132s | DBIx::Class::Storage::DBI::::__ANON__[:790]DBIx::Class::Storage::DBI::__ANON__[:790]
8019 | 1 | 1 | 56.7ms | 652ms | DBIx::Class::Storage::DBI::::_sthDBIx::Class::Storage::DBI::_sth
8019 | 1 | 1 | 54.7ms | 8.68s | DBIx::Class::Storage::DBI::::_prep_for_executeDBIx::Class::Storage::DBI::_prep_for_execute
8088 | 2 | 1 | 54.2ms | 54.2ms | DBIx::Class::Storage::DBI::::_query_endDBIx::Class::Storage::DBI::_query_end
8090 | 2 | 1 | 34.6ms | 35.4ms | DBIx::Class::Storage::DBI::::_query_startDBIx::Class::Storage::DBI::_query_start
1690 | 2 | 2 | 15.8ms | 80.5s | DBIx::Class::Storage::DBI::::updateDBIx::Class::Storage::DBI::update
449 | 1 | 1 | 12.9ms | 36.4ms | DBIx::Class::Storage::DBI::::_prefetch_autovaluesDBIx::Class::Storage::DBI::_prefetch_autovalues
294 | 1 | 1 | 10.6ms | 34.9s | DBIx::Class::Storage::DBI::::txn_commitDBIx::Class::Storage::DBI::txn_commit
6 | 1 | 1 | 10.3ms | 19.4ms | DBIx::Class::Storage::DBI::::__ANON__[:1300]DBIx::Class::Storage::DBI::__ANON__[:1300]
294 | 1 | 1 | 9.80ms | 34.8s | DBIx::Class::Storage::DBI::::_exec_txn_commitDBIx::Class::Storage::DBI::_exec_txn_commit
588 | 2 | 2 | 8.34ms | 61.8ms | DBIx::Class::Storage::DBI::::txn_beginDBIx::Class::Storage::DBI::txn_begin
1949 | 1 | 1 | 7.59ms | 7.59ms | DBIx::Class::Storage::DBI::::_count_selectDBIx::Class::Storage::DBI::_count_select
79 | 1 | 1 | 7.38ms | 7.96s | DBIx::Class::Storage::DBI::::__ANON__[:2767]DBIx::Class::Storage::DBI::__ANON__[:2767]
296 | 1 | 1 | 5.42ms | 19.8ms | DBIx::Class::Storage::DBI::::_dbh_last_insert_idDBIx::Class::Storage::DBI::_dbh_last_insert_id
592 | 2 | 1 | 4.08ms | 4.10ms | DBIx::Class::Storage::DBI::::get_dbms_capabilityDBIx::Class::Storage::DBI::get_dbms_capability
296 | 1 | 1 | 3.85ms | 5.91ms | DBIx::Class::Storage::DBI::::__ANON__[:2358]DBIx::Class::Storage::DBI::__ANON__[:2358]
296 | 1 | 1 | 3.72ms | 23.5ms | DBIx::Class::Storage::DBI::::last_insert_idDBIx::Class::Storage::DBI::last_insert_id
294 | 1 | 1 | 3.34ms | 38.5ms | DBIx::Class::Storage::DBI::::_exec_txn_beginDBIx::Class::Storage::DBI::_exec_txn_begin
296 | 1 | 1 | 2.94ms | 2.94ms | DBIx::Class::Storage::DBI::::CORE:substDBIx::Class::Storage::DBI::CORE:subst (opcode)
294 | 1 | 1 | 1.95ms | 14.3ms | DBIx::Class::Storage::DBI::::__ANON__[:1339]DBIx::Class::Storage::DBI::__ANON__[:1339]
322 | 8 | 1 | 1.59ms | 1.59ms | DBIx::Class::Storage::DBI::::CORE:matchDBIx::Class::Storage::DBI::CORE:match (opcode)
294 | 2 | 2 | 1.53ms | 12.3ms | DBIx::Class::Storage::DBI::::datetime_parserDBIx::Class::Storage::DBI::datetime_parser
71 | 1 | 1 | 1.32ms | 7.94s | DBIx::Class::Storage::DBI::::__ANON__[:2763]DBIx::Class::Storage::DBI::__ANON__[:2763]
71 | 1 | 1 | 1.23ms | 7.93s | DBIx::Class::Storage::DBI::::__ANON__[:2762]DBIx::Class::Storage::DBI::__ANON__[:2762]
4 | 1 | 1 | 1.08ms | 8.22s | DBIx::Class::Storage::DBI::::deployDBIx::Class::Storage::DBI::deploy
294 | 2 | 2 | 1.03ms | 1.03ms | DBIx::Class::Storage::DBI::::relname_to_table_aliasDBIx::Class::Storage::DBI::relname_to_table_alias
38 | 2 | 2 | 470µs | 2.15s | DBIx::Class::Storage::DBI::::deleteDBIx::Class::Storage::DBI::delete
13 | 3 | 1 | 445µs | 2.66ms | DBIx::Class::Storage::DBI::::_determine_driverDBIx::Class::Storage::DBI::_determine_driver
10 | 3 | 3 | 324µs | 238ms | DBIx::Class::Storage::DBI::::deployment_statementsDBIx::Class::Storage::DBI::deployment_statements
6 | 1 | 1 | 265µs | 20.2ms | DBIx::Class::Storage::DBI::::_connectDBIx::Class::Storage::DBI::_connect
9 | 2 | 2 | 225µs | 752µs | DBIx::Class::Storage::DBI::::connect_infoDBIx::Class::Storage::DBI::connect_info
6 | 1 | 1 | 209µs | 20.7ms | DBIx::Class::Storage::DBI::::_populate_dbhDBIx::Class::Storage::DBI::_populate_dbh
8 | 2 | 2 | 174µs | 18.3ms | DBIx::Class::Storage::DBI::::_server_infoDBIx::Class::Storage::DBI::_server_info
6 | 1 | 1 | 118µs | 144µs | DBIx::Class::Storage::DBI::::__ANON__[:1298]DBIx::Class::Storage::DBI::__ANON__[:1298]
6 | 1 | 1 | 111µs | 709µs | DBIx::Class::Storage::DBI::::newDBIx::Class::Storage::DBI::new
6 | 1 | 1 | 103µs | 103µs | DBIx::Class::Storage::DBI::::_normalize_connect_infoDBIx::Class::Storage::DBI::_normalize_connect_info
6 | 1 | 1 | 81µs | 326µs | DBIx::Class::Storage::DBI::::_run_connection_actionsDBIx::Class::Storage::DBI::_run_connection_actions
2 | 1 | 1 | 68µs | 212µs | DBIx::Class::Storage::DBI::::connectedDBIx::Class::Storage::DBI::connected
1 | 1 | 1 | 66µs | 106µs | DBIx::Class::Storage::DBI::::ENDDBIx::Class::Storage::DBI::END
8 | 2 | 1 | 60µs | 110µs | DBIx::Class::Storage::DBI::::sqlt_typeDBIx::Class::Storage::DBI::sqlt_type
6 | 1 | 1 | 45µs | 59µs | DBIx::Class::Storage::DBI::::_arm_global_destructorDBIx::Class::Storage::DBI::_arm_global_destructor
6 | 1 | 1 | 43µs | 139µs | DBIx::Class::Storage::DBI::::_parse_connect_doDBIx::Class::Storage::DBI::_parse_connect_do
4 | 1 | 1 | 35µs | 17.9ms | DBIx::Class::Storage::DBI::::__ANON__[:1116]DBIx::Class::Storage::DBI::__ANON__[:1116]
4 | 1 | 1 | 33µs | 33µs | DBIx::Class::Storage::DBI::::CORE:ftfileDBIx::Class::Storage::DBI::CORE:ftfile (opcode)
4 | 1 | 1 | 33µs | 18.0ms | DBIx::Class::Storage::DBI::::_dbh_get_infoDBIx::Class::Storage::DBI::_dbh_get_info
8 | 2 | 1 | 32µs | 18.0ms | DBIx::Class::Storage::DBI::::_get_server_versionDBIx::Class::Storage::DBI::_get_server_version
4 | 1 | 1 | 32µs | 18.0ms | DBIx::Class::Storage::DBI::::__ANON__[:1078]DBIx::Class::Storage::DBI::__ANON__[:1078]
2 | 1 | 1 | 29µs | 4.63ms | DBIx::Class::Storage::DBI::::__ANON__[:1297]DBIx::Class::Storage::DBI::__ANON__[:1297]
3 | 1 | 1 | 26µs | 42µs | DBIx::Class::Storage::DBI::::is_datatype_numericDBIx::Class::Storage::DBI::is_datatype_numeric
2 | 1 | 1 | 25µs | 43µs | DBIx::Class::Storage::DBI::::_seems_connectedDBIx::Class::Storage::DBI::_seems_connected
2 | 1 | 1 | 24µs | 357µs | DBIx::Class::Storage::DBI::::__ANON__[:800]DBIx::Class::Storage::DBI::__ANON__[:800]
6 | 1 | 1 | 18µs | 18µs | DBIx::Class::Storage::DBI::::_default_dbi_connect_attributesDBIx::Class::Storage::DBI::_default_dbi_connect_attributes
1 | 1 | 1 | 17µs | 22µs | DBIx::Class::Storage::DBI::::BEGIN@4DBIx::Class::Storage::DBI::BEGIN@4
2 | 1 | 1 | 15µs | 89µs | DBIx::Class::Storage::DBI::::_pingDBIx::Class::Storage::DBI::_ping
2 | 2 | 1 | 15µs | 10.8ms | DBIx::Class::Storage::DBI::::build_datetime_parserDBIx::Class::Storage::DBI::build_datetime_parser
1 | 1 | 1 | 14µs | 39µs | DBIx::Class::Storage::DBI::::BEGIN@1407DBIx::Class::Storage::DBI::BEGIN@1407
6 | 1 | 1 | 13µs | 13µs | DBIx::Class::Storage::DBI::::_reblessDBIx::Class::Storage::DBI::_rebless
6 | 1 | 1 | 11µs | 11µs | DBIx::Class::Storage::DBI::::__ANON__[:1306]DBIx::Class::Storage::DBI::__ANON__[:1306]
1 | 1 | 1 | 10µs | 29µs | DBIx::Class::Storage::DBI::::BEGIN@110DBIx::Class::Storage::DBI::BEGIN@110
6 | 1 | 1 | 9µs | 9µs | DBIx::Class::Storage::DBI::::_initDBIx::Class::Storage::DBI::_init
1 | 1 | 1 | 9µs | 8.73ms | DBIx::Class::Storage::DBI::::BEGIN@7DBIx::Class::Storage::DBI::BEGIN@7
1 | 1 | 1 | 9µs | 62µs | DBIx::Class::Storage::DBI::::BEGIN@12DBIx::Class::Storage::DBI::BEGIN@12
1 | 1 | 1 | 9µs | 90µs | DBIx::Class::Storage::DBI::::BEGIN@10DBIx::Class::Storage::DBI::BEGIN@10
1 | 1 | 1 | 9µs | 26µs | DBIx::Class::Storage::DBI::::BEGIN@5DBIx::Class::Storage::DBI::BEGIN@5
1 | 1 | 1 | 9µs | 18µs | DBIx::Class::Storage::DBI::::BEGIN@8DBIx::Class::Storage::DBI::BEGIN@8
1 | 1 | 1 | 9µs | 41µs | DBIx::Class::Storage::DBI::::BEGIN@15DBIx::Class::Storage::DBI::BEGIN@15
1 | 1 | 1 | 8µs | 20µs | DBIx::Class::Storage::DBI::::BEGIN@109DBIx::Class::Storage::DBI::BEGIN@109
1 | 1 | 1 | 8µs | 246µs | DBIx::Class::Storage::DBI::::BEGIN@17DBIx::Class::Storage::DBI::BEGIN@17
1 | 1 | 1 | 7µs | 26µs | DBIx::Class::Storage::DBI::::BEGIN@13DBIx::Class::Storage::DBI::BEGIN@13
1 | 1 | 1 | 7µs | 7µs | DBIx::Class::Storage::DBI::::BEGIN@11DBIx::Class::Storage::DBI::BEGIN@11
1 | 1 | 1 | 7µs | 25µs | DBIx::Class::Storage::DBI::::BEGIN@14DBIx::Class::Storage::DBI::BEGIN@14
1 | 1 | 1 | 6µs | 7µs | DBIx::Class::Storage::DBI::::set_dbms_capabilityDBIx::Class::Storage::DBI::set_dbms_capability
1 | 1 | 1 | 6µs | 13µs | DBIx::Class::Storage::DBI::::set_use_dbms_capabilityDBIx::Class::Storage::DBI::set_use_dbms_capability
4 | 3 | 2 | 4µs | 4µs | DBIx::Class::Storage::DBI::::schemaDBIx::Class::Storage::DBI::schema (xsub)
1 | 1 | 1 | 4µs | 4µs | DBIx::Class::Storage::DBI::::BEGIN@16DBIx::Class::Storage::DBI::BEGIN@16
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::CLONEDBIx::Class::Storage::DBI::CLONE
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::DESTROYDBIx::Class::Storage::DBI::DESTROY
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::__ANON__[:1303]DBIx::Class::Storage::DBI::__ANON__[:1303]
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::__ANON__[:132]DBIx::Class::Storage::DBI::__ANON__[:132]
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::__ANON__[:1414]DBIx::Class::Storage::DBI::__ANON__[:1414]
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::__ANON__[:1455]DBIx::Class::Storage::DBI::__ANON__[:1455]
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::__ANON__[:1676]DBIx::Class::Storage::DBI::__ANON__[:1676]
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::__ANON__[:1680]DBIx::Class::Storage::DBI::__ANON__[:1680]
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::__ANON__[:1772]DBIx::Class::Storage::DBI::__ANON__[:1772]
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::__ANON__[:1903]DBIx::Class::Storage::DBI::__ANON__[:1903]
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::__ANON__[:1906]DBIx::Class::Storage::DBI::__ANON__[:1906]
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::__ANON__[:1919]DBIx::Class::Storage::DBI::__ANON__[:1919]
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::__ANON__[:1922]DBIx::Class::Storage::DBI::__ANON__[:1922]
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::__ANON__[:1956]DBIx::Class::Storage::DBI::__ANON__[:1956]
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::__ANON__[:1959]DBIx::Class::Storage::DBI::__ANON__[:1959]
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::__ANON__[:1964]DBIx::Class::Storage::DBI::__ANON__[:1964]
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::__ANON__[:1967]DBIx::Class::Storage::DBI::__ANON__[:1967]
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::__ANON__[:228]DBIx::Class::Storage::DBI::__ANON__[:228]
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::__ANON__[:2305]DBIx::Class::Storage::DBI::__ANON__[:2305]
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::__ANON__[:2307]DBIx::Class::Storage::DBI::__ANON__[:2307]
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::__ANON__[:2414]DBIx::Class::Storage::DBI::__ANON__[:2414]
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::__ANON__[:2417]DBIx::Class::Storage::DBI::__ANON__[:2417]
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::__ANON__[:2432]DBIx::Class::Storage::DBI::__ANON__[:2432]
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::__ANON__[:2435]DBIx::Class::Storage::DBI::__ANON__[:2435]
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::__ANON__[:2765]DBIx::Class::Storage::DBI::__ANON__[:2765]
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::_dbh_columns_info_forDBIx::Class::Storage::DBI::_dbh_columns_info_for
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::_dbh_execute_arrayDBIx::Class::Storage::DBI::_dbh_execute_array
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::_dbh_execute_inserts_with_no_bindsDBIx::Class::Storage::DBI::_dbh_execute_inserts_with_no_binds
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::_determine_supports_join_optimizerDBIx::Class::Storage::DBI::_determine_supports_join_optimizer
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::_determine_supports_placeholdersDBIx::Class::Storage::DBI::_determine_supports_placeholders
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::_determine_supports_typeless_placeholdersDBIx::Class::Storage::DBI::_determine_supports_typeless_placeholders
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::_do_connection_actionsDBIx::Class::Storage::DBI::_do_connection_actions
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::_do_queryDBIx::Class::Storage::DBI::_do_query
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::_exec_txn_rollbackDBIx::Class::Storage::DBI::_exec_txn_rollback
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::_execute_arrayDBIx::Class::Storage::DBI::_execute_array
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::_format_for_traceDBIx::Class::Storage::DBI::_format_for_trace
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::_is_binary_lob_typeDBIx::Class::Storage::DBI::_is_binary_lob_type
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::_is_lob_typeDBIx::Class::Storage::DBI::_is_lob_type
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::_is_text_lob_typeDBIx::Class::Storage::DBI::_is_text_lob_type
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::_max_column_bytesizeDBIx::Class::Storage::DBI::_max_column_bytesize
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::_multipk_update_deleteDBIx::Class::Storage::DBI::_multipk_update_delete
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::_native_data_typeDBIx::Class::Storage::DBI::_native_data_type
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::_per_row_update_deleteDBIx::Class::Storage::DBI::_per_row_update_delete
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::_select_args_to_queryDBIx::Class::Storage::DBI::_select_args_to_query
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::_subq_update_deleteDBIx::Class::Storage::DBI::_subq_update_delete
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::bind_attribute_by_data_typeDBIx::Class::Storage::DBI::bind_attribute_by_data_type
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::columns_info_forDBIx::Class::Storage::DBI::columns_info_for
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::connect_call_datetime_setupDBIx::Class::Storage::DBI::connect_call_datetime_setup
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::connect_call_do_sqlDBIx::Class::Storage::DBI::connect_call_do_sql
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::create_ddl_dirDBIx::Class::Storage::DBI::create_ddl_dir
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::dbhDBIx::Class::Storage::DBI::dbh
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::disconnectDBIx::Class::Storage::DBI::disconnect
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::disconnect_call_do_sqlDBIx::Class::Storage::DBI::disconnect_call_do_sql
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::ensure_connectedDBIx::Class::Storage::DBI::ensure_connected
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::insert_bulkDBIx::Class::Storage::DBI::insert_bulk
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::is_replicatingDBIx::Class::Storage::DBI::is_replicating
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::lag_behind_masterDBIx::Class::Storage::DBI::lag_behind_master
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::source_bind_attributesDBIx::Class::Storage::DBI::source_bind_attributes
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::sthDBIx::Class::Storage::DBI::sth
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::txn_doDBIx::Class::Storage::DBI::txn_do
0 | 0 | 0 | 0s | 0s | DBIx::Class::Storage::DBI::::txn_rollbackDBIx::Class::Storage::DBI::txn_rollback
0 | 0 | 0 | 0s | 0s | DBIx::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
--- | --- | --- | --- | --- | ---
1 |  |  |  |  | package DBIx::Class::Storage::DBI;
2 |  |  |  |  | # -*- mode: cperl; cperl-indent-level: 2 -*-
3 |  |  |  |  |
4 | 3 | 22µs | 2 | 28µ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
5 | 3 | 26µs | 2 | 43µ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 |  |  |  |  |
7 | 3 | 30µs | 2 | 17.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
8 | 3 | 21µs | 2 | 27µ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 |  |  |  |  |
10 | 3 | 24µs | 2 | 172µ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
11 | 3 | 22µs | 1 | 7µ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
12 | 3 | 22µs | 2 | 115µ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
13 | 3 | 18µs | 2 | 45µ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
14 | 3 | 17µs | 2 | 44µ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
15 | 3 | 18µs | 2 | 74µ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
16 | 3 | 16µs | 1 | 4µ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
17 | 3 | 205µs | 2 | 484µ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
20 | 1 | 13µs | 1 | 50µs | __PACKAGE__->cursor_class('DBIx::Class::Storage::DBI::Cursor'); # spent 50µs making 1 call to DBIx::Class::Storage::cursor_class
21 |  |  |  |  |
22 | 1 | 9µs | 1 | 463µ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 |  |  |  |  |
26 | 1 | 2µs | 1 | 276µ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 |  |  |  |  |
28 | 1 | 1µs | 1 | 15µs | __PACKAGE__->sql_maker_class('DBIx::Class::SQLMaker'); # spent 15µs making 1 call to DBIx::Class::Storage::DBI::sql_maker_class
29 | 1 | 1µs | 1 | 12µs | __PACKAGE__->datetime_parser_type('DateTime::Format::MySQL'); # historic default # spent 12µs making 1 call to DBIx::Class::Storage::DBI::datetime_parser_type
30 |  |  |  |  |
31 | 1 | 1µs | 1 | 11µs | __PACKAGE__->sql_name_sep('.'); # spent 11µs making 1 call to DBIx::Class::Storage::DBI::sql_name_sep
32 |  |  |  |  |
33 | 1 | 2µs | 1 | 530µ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
40 | 1 | 2µs |  |  | my @storage_options = qw/
41 |  |  |  |  | on_connect_call on_disconnect_call on_connect_do on_disconnect_do
42 |  |  |  |  | disable_sth_caching unsafe auto_savepoint
43 |  |  |  |  | /;
44 | 1 | 2µs | 1 | 353µ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 |  |  |  |  |
61 | 1 | 2µs |  |  | my @capabilities = (qw/
62 |  |  |  |  | insert_returning
63 |  |  |  |  | insert_returning_bound
64 |  |  |  |  | placeholders
65 |  |  |  |  | typeless_placeholders
66 |  |  |  |  | join_optimizer
67 |  |  |  |  | /);
68 | 1 | 5µs | 1 | 610µs | __PACKAGE__->mk_group_accessors( dbms_capability => map { "_supports_$_" } @capabilities ); # spent 610µs making 1 call to Class::Accessor::Grouped::mk_group_accessors
69 | 1 | 4µs | 1 | 595µ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)
72 | 1 | 2µs | 1 | 18µs | __PACKAGE__->_use_join_optimizer (1); # spent 18µs making 1 call to DBIx::Class::Storage::DBI::_use_join_optimizer
73 |  |  |  |  | sub _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
81 | 1 | 4µs |  |  | my @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 |  |  |  |  |
104 | 1 | 1µs |  |  | for my $meth (@rdbms_specific_methods) {
105 |  |  |  |  |
106 | 17 | 57µs | 17 | 27µ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 |  |  |  |  |
109 | 3 | 24µs | 2 | 32µ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
110 | 3 | 3.23ms | 2 | 48µ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 {
112 | 32463 | 58.1ms | 2 | 111µ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 |  |  |  |  | ) {
121 | 6 | 24µs | 6 | 2.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 |  |  |  |  |
127 | 6 | 71µs | 6 | 24µs | my $cref = $_[0]->can ($meth); # spent 24µs making 6 calls to UNIVERSAL::can, avg 4µs/call
128 | 6 | 51µs | 6 | 247ms | 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 |  |  |  |  |
131 | 32457 | 200ms | 32457 | 123s | 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
132 | 17 | 114µs | 17 | 24µs | }; # spent 24µs making 17 calls to Sub::Name::subname, avg 1µs/call
133 |  |  |  |  | }
134 |  |  |  |  |
135 |  |  |  |  | =head1 NAME
136 |  |  |  |  |
137 |  |  |  |  | DBIx::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 |  |  |  |  |
159 |  |  |  |  | This class represents the connection to an RDBMS via L<DBI>. See
160 |  |  |  |  | L<DBIx::Class::Storage> for general information. This pod only
161 |  |  |  |  | documents 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 {
168 | 6 | 16µs | 6 | 49µs | my $new = shift->next::method(@_); # spent 49µs making 6 calls to next::method, avg 8µs/call
169 |  |  |  |  |
170 | 6 | 11µs | 2 | 94µs | $new->_sql_maker_opts({}); # spent 94µs making 2 calls to DBIx::Class::Storage::DBI::_sql_maker_opts, avg 47µs/call
171 | 6 | 9µs | 2 | 90µs | $new->_dbh_details({}); # spent 90µs making 2 calls to DBIx::Class::Storage::DBI::_dbh_details, avg 45µs/call
172 | 6 | 5µs |  |  | $new->{_in_do_block} = 0;
173 | 6 | 4µs |  |  | $new->{_dbh_gen} = 0;
174 |  |  |  |  |
175 |  |  |  |  | # read below to see what this does
176 | 6 | 10µs | 6 | 59µ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 | 6 | 13µs |  |  | $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 |  |  |  |  | {
190 | 2 | 2µ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 {
193 | 6 | 2µs |  |  | my $self = shift;
194 | 6 | 24µs | 6 | 9µs | my $key = refaddr ($self); # spent 9µs making 6 calls to Scalar::Util::refaddr, avg 1µs/call
195 | 6 | 8µs |  |  | $seek_and_destroy{$key} = $self;
196 | 6 | 30µs | 6 | 5µ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 {
200 | 1 | 2µs |  |  | local $?; # just in case the DBI destructor changes it somehow
201 |  |  |  |  |
202 |  |  |  |  | # destroy just the object if not native to this process/thread
203 | 1 | 48µs | 6 | 39µ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 | 1 | 400ns |  |  | );
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 |  |  |  |  |
224 |  |  |  |  | sub 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 {
240 | 22890 | 8.02ms |  |  | my $self = shift;
241 |  |  |  |  |
242 | 22890 | 25.6ms | 2 | 158µ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 | 22890 | 14.0ms |  |  | 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 | 22890 | 66.8ms |  |  | return;
252 |  |  |  |  | }
253 |  |  |  |  |
254 |  |  |  |  | =head2 connect_info
255 |  |  |  |  |
256 |  |  |  |  | This method is normally called by L<DBIx::Class::Schema/connection>, which
257 |  |  |  |  | encapsulates its argument list in an arrayref before passing them here.
258 |  |  |  |  |
259 |  |  |  |  | The argument list may contain:
260 |  |  |  |  |
261 |  |  |  |  | =over
262 |  |  |  |  |
263 |  |  |  |  | =item *
264 |  |  |  |  |
265 |  |  |  |  | The same 4-element argument set one would normally pass to
266 |  |  |  |  | L<DBI/connect>, optionally followed by
267 |  |  |  |  | L<extra attributes|/DBIx::Class specific connection attributes>
268 |  |  |  |  | recognized by DBIx::Class:
269 |  |  |  |  |
270 |  |  |  |  | $connect_info_args = [ $dsn, $user, $password, \%dbi_attributes?, \%extra_attributes? ];
271 |  |  |  |  |
272 |  |  |  |  | =item *
273 |  |  |  |  |
274 |  |  |  |  | A single code reference which returns a connected
275 |  |  |  |  | L<DBI database handle|DBI/connect> optionally followed by
276 |  |  |  |  | L<extra attributes|/DBIx::Class specific connection attributes> recognized
277 |  |  |  |  | by DBIx::Class:
278 |  |  |  |  |
279 |  |  |  |  | $connect_info_args = [ sub { DBI->connect (...) }, \%extra_attributes? ];
280 |  |  |  |  |
281 |  |  |  |  | =item *
282 |  |  |  |  |
283 |  |  |  |  | A single hashref with all the attributes and the dsn/user/password
284 |  |  |  |  | mixed 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 |  |  |  |  |
300 |  |  |  |  | This is particularly useful for L<Catalyst> based applications, allowing the
301 |  |  |  |  | following 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 |  |  |  |  |
313 |  |  |  |  | The C<dsn>/C<user>/C<password> combination can be substituted by the
314 |  |  |  |  | C<dbh_maker> key whose value is a coderef that returns a connected
315 |  |  |  |  | L<DBI database handle|DBI/connect>
316 |  |  |  |  |
317 |  |  |  |  | =back
318 |  |  |  |  |
319 |  |  |  |  | Please note that the L<DBI> docs recommend that you always explicitly
320 |  |  |  |  | set C<AutoCommit> to either I<0> or I<1>. L<DBIx::Class> further
321 |  |  |  |  | recommends that it be set to I<1>, and that you perform transactions
322 |  |  |  |  | via our L<DBIx::Class::Schema/txn_do> method. L<DBIx::Class> will set it
323 |  |  |  |  | to I<1> if you do not do explicitly set it to zero. This is the default
324 |  |  |  |  | for most DBDs. See L</DBIx::Class and AutoCommit> for details.
325 |  |  |  |  |
326 |  |  |  |  | =head3 DBIx::Class specific connection attributes
327 |  |  |  |  |
328 |  |  |  |  | In addition to the standard L<DBI|DBI/ATTRIBUTES_COMMON_TO_ALL_HANDLES>
329 |  |  |  |  | L<connection|DBI/Database_Handle_Attributes> attributes, DBIx::Class recognizes
330 |  |  |  |  | the following connection options. These options can be mixed in with your other
331 |  |  |  |  | L<DBI> connection attributes, or placed in a separate hashref
332 |  |  |  |  | (C<\%extra_attributes>) as shown above.
333 |  |  |  |  |
334 |  |  |  |  | Every time C<connect_info> is invoked, any previous settings for
335 |  |  |  |  | these options will be cleared before setting the new ones, regardless of
336 |  |  |  |  | whether any options are specified in the new C<connect_info>.
337 |  |  |  |  |
338 |  |  |  |  |
339 |  |  |  |  | =over
340 |  |  |  |  |
341 |  |  |  |  | =item on_connect_do
342 |  |  |  |  |
343 |  |  |  |  | Specifies things to do immediately after connecting or re-connecting to
344 |  |  |  |  | the database. Its value may contain:
345 |  |  |  |  |
346 |  |  |  |  | =over
347 |  |  |  |  |
348 |  |  |  |  | =item a scalar
349 |  |  |  |  |
350 |  |  |  |  | This contains one SQL statement to execute.
351 |  |  |  |  |
352 |  |  |  |  | =item an array reference
353 |  |  |  |  |
354 |  |  |  |  | This contains SQL statements to execute in order. Each element contains
355 |  |  |  |  | a string or a code reference that returns a string.
356 |  |  |  |  |
357 |  |  |  |  | =item a code reference
358 |  |  |  |  |
359 |  |  |  |  | This contains some code to execute. Unlike code references within an
360 |  |  |  |  | array reference, its return value is ignored.
361 |  |  |  |  |
362 |  |  |  |  | =back
363 |  |  |  |  |
364 |  |  |  |  | =item on_disconnect_do
365 |  |  |  |  |
366 |  |  |  |  | Takes arguments in the same form as L</on_connect_do> and executes them
367 |  |  |  |  | immediately before disconnecting from the database.
368 |  |  |  |  |
369 |  |  |  |  | Note, this only runs if you explicitly call L</disconnect> on the
370 |  |  |  |  | storage object.
371 |  |  |  |  |
372 |  |  |  |  | =item on_connect_call
373 |  |  |  |  |
374 |  |  |  |  | A more generalized form of L</on_connect_do> that calls the specified
375 |  |  |  |  | C<connect_call_METHOD> methods in your storage driver.
376 |  |  |  |  |
377 |  |  |  |  | on_connect_do => 'select 1'
378 |  |  |  |  |
379 |  |  |  |  | is equivalent to:
380 |  |  |  |  |
381 |  |  |  |  | on_connect_call => [ [ do_sql => 'select 1' ] ]
382 |  |  |  |  |
383 |  |  |  |  | Its values may contain:
384 |  |  |  |  |
385 |  |  |  |  | =over
386 |  |  |  |  |
387 |  |  |  |  | =item a scalar
388 |  |  |  |  |
389 |  |  |  |  | Will call the C<connect_call_METHOD> method.
390 |  |  |  |  |
391 |  |  |  |  | =item a code reference
392 |  |  |  |  |
393 |  |  |  |  | Will execute C<< $code->($storage) >>
394 |  |  |  |  |
395 |  |  |  |  | =item an array reference
396 |  |  |  |  |
397 |  |  |  |  | Each value can be a method name or code reference.
398 |  |  |  |  |
399 |  |  |  |  | =item an array of arrays
400 |  |  |  |  |
401 |  |  |  |  | For each array, the first item is taken to be the C<connect_call_> method name
402 |  |  |  |  | or code reference, and the rest are parameters to it.
403 |  |  |  |  |
404 |  |  |  |  | =back
405 |  |  |  |  |
406 |  |  |  |  | Some predefined storage methods you may use:
407 |  |  |  |  |
408 |  |  |  |  | =over
409 |  |  |  |  |
410 |  |  |  |  | =item do_sql
411 |  |  |  |  |
412 |  |  |  |  | Executes a SQL string or a code reference that returns a SQL string. This is
413 |  |  |  |  | what L</on_connect_do> and L</on_disconnect_do> use.
414 |  |  |  |  |
415 |  |  |  |  | It can take:
416 |  |  |  |  |
417 |  |  |  |  | =over
418 |  |  |  |  |
419 |  |  |  |  | =item a scalar
420 |  |  |  |  |
421 |  |  |  |  | Will execute the scalar as SQL.
422 |  |  |  |  |
423 |  |  |  |  | =item an arrayref
424 |  |  |  |  |
425 |  |  |  |  | Taken to be arguments to L<DBI/do>, the SQL string optionally followed by the
426 |  |  |  |  | attributes hashref and bind values.
427 |  |  |  |  |
428 |  |  |  |  | =item a code reference
429 |  |  |  |  |
430 |  |  |  |  | Will execute C<< $code->($storage) >> and execute the return array refs as
431 |  |  |  |  | above.
432 |  |  |  |  |
433 |  |  |  |  | =back
434 |  |  |  |  |
435 |  |  |  |  | =item datetime_setup
436 |  |  |  |  |
437 |  |  |  |  | Execute any statements necessary to initialize the database session to return
438 |  |  |  |  | and accept datetime/timestamp values used with
439 |  |  |  |  | L<DBIx::Class::InflateColumn::DateTime>.
440 |  |  |  |  |
441 |  |  |  |  | Only necessary for some databases, see your specific storage driver for
442 |  |  |  |  | implementation details.
443 |  |  |  |  |
444 |  |  |  |  | =back
445 |  |  |  |  |
446 |  |  |  |  | =item on_disconnect_call
447 |  |  |  |  |
448 |  |  |  |  | Takes arguments in the same form as L</on_connect_call> and executes them
449 |  |  |  |  | immediately before disconnecting from the database.
450 |  |  |  |  |
451 |  |  |  |  | Calls the C<disconnect_call_METHOD> methods as opposed to the
452 |  |  |  |  | C<connect_call_METHOD> methods called by L</on_connect_call>.
453 |  |  |  |  |
454 |  |  |  |  | Note, this only runs if you explicitly call L</disconnect> on the
455 |  |  |  |  | storage object.
456 |  |  |  |  |
457 |  |  |  |  | =item disable_sth_caching
458 |  |  |  |  |
459 |  |  |  |  | If set to a true value, this option will disable the caching of
460 |  |  |  |  | statement handles via L<DBI/prepare_cached>.
461 |  |  |  |  |
462 |  |  |  |  | =item limit_dialect
463 |  |  |  |  |
464 |  |  |  |  | Sets a specific SQL::Abstract::Limit-style limit dialect, overriding the
465 |  |  |  |  | default L</sql_limit_dialect> setting of the storage (if any). For a list
466 |  |  |  |  | of available limit dialects see L<DBIx::Class::SQLMaker::LimitDialects>.
467 |  |  |  |  |
468 |  |  |  |  | =item quote_names
469 |  |  |  |  |
470 |  |  |  |  | When true automatically sets L</quote_char> and L</name_sep> to the characters
471 |  |  |  |  | appropriate for your particular RDBMS. This option is preferred over specifying
472 |  |  |  |  | L</quote_char> directly.
473 |  |  |  |  |
474 |  |  |  |  | =item quote_char
475 |  |  |  |  |
476 |  |  |  |  | Specifies what characters to use to quote table and column names.
477 |  |  |  |  |
478 |  |  |  |  | C<quote_char> expects either a single character, in which case is it
479 |  |  |  |  | is placed on either side of the table/column name, or an arrayref of length
480 |  |  |  |  | 2 in which case the table/column name is placed between the elements.
481 |  |  |  |  |
482 |  |  |  |  | For example under MySQL you should use C<< quote_char => '`' >>, and for
483 |  |  |  |  | SQL Server you should use C<< quote_char => [qw/[ ]/] >>.
484 |  |  |  |  |
485 |  |  |  |  | =item name_sep
486 |  |  |  |  |
487 |  |  |  |  | This parameter is only useful in conjunction with C<quote_char>, and is used to
488 |  |  |  |  | specify the character that separates elements (schemas, tables, columns) from
489 |  |  |  |  | each other. If unspecified it defaults to the most commonly used C<.>.
490 |  |  |  |  |
491 |  |  |  |  | =item unsafe
492 |  |  |  |  |
493 |  |  |  |  | This Storage driver normally installs its own C<HandleError>, sets
494 |  |  |  |  | C<RaiseError> and C<ShowErrorStatement> on, and sets C<PrintError> off on
495 |  |  |  |  | all database handles, including those supplied by a coderef. It does this
496 |  |  |  |  | so that it can have consistent and useful error behavior.
497 |  |  |  |  |
498 |  |  |  |  | If you set this option to a true value, Storage will not do its usual
499 |  |  |  |  | modifications to the database handle's attributes, and instead relies on
500 |  |  |  |  | the settings in your connect_info DBI options (or the values you set in
501 |  |  |  |  | your connection coderef, in the case that you are connecting via coderef).
502 |  |  |  |  |
503 |  |  |  |  | Note that your custom settings can cause Storage to malfunction,
504 |  |  |  |  | especially if you set a C<HandleError> handler that suppresses exceptions
505 |  |  |  |  | and/or disable C<RaiseError>.
506 |  |  |  |  |
507 |  |  |  |  | =item auto_savepoint
508 |  |  |  |  |
509 |  |  |  |  | If this option is true, L<DBIx::Class> will use savepoints when nesting
510 |  |  |  |  | transactions, making it possible to recover from failure in the inner
511 |  |  |  |  | transaction without having to abort all outer transactions.
512 |  |  |  |  |
513 |  |  |  |  | =item cursor_class
514 |  |  |  |  |
515 |  |  |  |  | Use this argument to supply a cursor class other than the default
516 |  |  |  |  | L<DBIx::Class::Storage::DBI::Cursor>.
517 |  |  |  |  |
518 |  |  |  |  | =back
519 |  |  |  |  |
520 |  |  |  |  | Some real-life examples of arguments to L</connect_info> and
521 |  |  |  |  | L<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 {
587 | 9 | 5µs |  |  | my ($self, $info) = @_;
588 |  |  |  |  |
589 | 9 | 12µs | 1 | 700ns | return $self->_connect_info if !$info; # spent 700ns making 1 call to DBIx::Class::Storage::DBI::_connect_info
590 |  |  |  |  |
591 | 6 | 8µs | 2 | 109µ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 |  |  |  |  |
593 | 6 | 15µs | 6 | 103µ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 | 6 | 11µs |  |  | 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
604 | 6 | 12µs | 2 | 92µs | $self->_sql_maker(undef); # spent 92µs making 2 calls to DBIx::Class::Storage::DBI::_sql_maker, avg 46µs/call
605 | 6 | 9µs | 1 | 1µs | $self->_sql_maker_opts({}); # spent 1µs making 1 call to DBIx::Class::Storage::DBI::_sql_maker_opts
606 |  |  |  |  |
607 | 6 | 10µs |  |  | 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 || {} },
615 | 6 | 33µs | 6 | 18µ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 | 6 | 10µs |  |  | my @args = @{ $info->{arguments} };
619 |  |  |  |  |
620 | 6 | 7µs |  |  | if (keys %attrs and ref $args[0] ne 'CODE') {
621 | 6 | 2µs |  |  | 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 | 6 | 6µs |  |  | push @args, \%attrs if keys %attrs;
630 |  |  |  |  | }
631 | 6 | 9µs | 2 | 104µ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
636 | 6 | 8µs | 2 | 98µ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 |  |  |  |  |
638 | 6 | 26µs | 1 | 700ns | 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 {
642 | 6 | 3µs |  |  | my ($self, $info_arg) = @_;
643 | 6 | 1µs |  |  | my %info;
644 |  |  |  |  |
645 | 6 | 12µs |  |  | my @args = @$info_arg; # take a shallow copy for further mutilation
646 |  |  |  |  |
647 |  |  |  |  | # combine/pre-parse arguments depending on invocation style
648 |  |  |  |  |
649 | 6 | 2µs |  |  | my %attrs;
650 | 6 | 8µs |  |  | 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 | 6 | 15µs |  |  | % { $args[4] || {} },
678 |  |  |  |  | );
679 | 6 | 11µs |  |  | @args = @args[0,1,2];
680 |  |  |  |  | }
681 |  |  |  |  |
682 | 6 | 7µs |  |  | $info{arguments} = \@args;
683 |  |  |  |  |
684 | 6 | 18µs |  |  | my @storage_opts = grep exists $attrs{$_},
685 |  |  |  |  | @storage_options, 'cursor_class';
686 |  |  |  |  |
687 | 6 | 2µs |  |  | @{ $info{storage_options} }{@storage_opts} =
688 |  |  |  |  | delete @attrs{@storage_opts} if @storage_opts;
689 |  |  |  |  |
690 | 6 | 7µs |  |  | my @sql_maker_opts = grep exists $attrs{$_},
691 |  |  |  |  | qw/limit_dialect quote_char name_sep quote_names/;
692 |  |  |  |  |
693 | 6 | 2µs |  |  | @{ $info{sql_maker_options} }{@sql_maker_opts} =
694 |  |  |  |  | delete @attrs{@sql_maker_opts} if @sql_maker_opts;
695 |  |  |  |  |
696 | 6 | 5µs |  |  | $info{attributes} = \%attrs if %attrs;
697 |  |  |  |  |
698 | 6 | 19µs |  |  | 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 |  |  |  |  | +{
703 | 6 | 25µs |  |  | AutoCommit => 1,
704 |  |  |  |  | PrintError => 0,
705 |  |  |  |  | RaiseError => 1,
706 |  |  |  |  | ShowErrorStatement => 1,
707 |  |  |  |  | };
708 |  |  |  |  | }
709 |  |  |  |  |
710 |  |  |  |  | =head2 on_connect_do
711 |  |  |  |  |
712 |  |  |  |  | This method is deprecated in favour of setting via L</connect_info>.
713 |  |  |  |  |
714 |  |  |  |  | =cut
715 |  |  |  |  |
716 |  |  |  |  | =head2 on_disconnect_do
717 |  |  |  |  |
718 |  |  |  |  | This 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 {
723 | 6 | 7µs |  |  | my ($self, $type) = @_;
724 |  |  |  |  |
725 | 6 | 15µs | 2 | 95µ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 | 6 | 24µs |  |  | 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 |  |  |  |  |
745 |  |  |  |  | Arguments: ($subref | $method_name), @extra_coderef_args?
746 |  |  |  |  |
747 |  |  |  |  | Execute the given $subref or $method_name using the new exception-based
748 |  |  |  |  | connection management.
749 |  |  |  |  |
750 |  |  |  |  | The first two arguments will be the storage object that C<dbh_do> was called
751 |  |  |  |  | on and a database handle to use. Any additional arguments will be passed
752 |  |  |  |  | verbatim to the called subref as arguments 2 and onwards.
753 |  |  |  |  |
754 |  |  |  |  | Using this (instead of $self->_dbh or $self->dbh) ensures correct
755 |  |  |  |  | exception handling and reconnection (or failover in future subclasses).
756 |  |  |  |  |
757 |  |  |  |  | Your subref should have no side-effects outside of the database, as
758 |  |  |  |  | there is the potential for your subref to be partially double-executed
759 |  |  |  |  | if the database connection was stale/dysfunctional.
760 |  |  |  |  |
761 |  |  |  |  | Example:
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 {
775 | 22286 | 10.5ms |  |  | my $self = shift;
776 | 22286 | 12.4ms |  |  | my $code = shift;
777 |  |  |  |  |
778 | 22286 | 49.2ms | 22286 | 232ms | my $dbh = $self->_get_dbh; # spent 232ms making 22286 calls to DBIx::Class::Storage::DBI::_get_dbh, avg 10µs/call
779 |  |  |  |  |
780 | 22286 | 102ms | 13012 | 1.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 | 9274 | 13.7ms |  |  | local $self->{_in_do_block} = 1;
784 |  |  |  |  |
785 |  |  |  |  | # take a ref instead of a copy, to preserve coderef @_ aliasing semantics
786 | 9274 | 8.63ms |  |  | 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 {
789 | 9274 | 68.1ms | 9274 | 131s | $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 {
791 | 2 | 11µs | 6 | 335µ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);
800 | 9274 | 146ms | 18548 | 124s | }; # 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 |  |  |  |  |
803 |  |  |  |  | sub 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 |  |  |  |  |
812 |  |  |  |  | Our C<disconnect> method also performs a rollback first if the
813 |  |  |  |  | database is not in C<AutoCommit> mode.
814 |  |  |  |  |
815 |  |  |  |  | =cut
816 |  |  |  |  |
817 |  |  |  |  | sub 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 |  |  |  |  |
848 |  |  |  |  | Storage specific method to run the code ref with FK checks deferred or
849 |  |  |  |  | in MySQL's case disabled entirely.
850 |  |  |  |  |
851 |  |  |  |  | =cut
852 |  |  |  |  |
853 |  |  |  |  | # Storage subclasses should override this
854 |  |  |  |  | sub 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 |  |  |  |  |
869 |  |  |  |  | Verifies that the current database handle is active and ready to execute
870 |  |  |  |  | an SQL statement (e.g. the connection did not get stale, server is still
871 |  |  |  |  | answering, 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 {
876 | 2 | 1µs |  |  | my $self = shift;
877 | 2 | 8µs | 2 | 43µ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
880 | 2 | 45µs | 5 | 10µ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 |  |  |  |  |
882 | 2 | 26µs | 2 | 89µ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 {
886 | 2 | 800ns |  |  | my $self = shift;
887 |  |  |  |  |
888 | 2 | 4µs | 2 | 9µs | $self->_verify_pid; # spent 9µs making 2 calls to DBIx::Class::Storage::DBI::_verify_pid, avg 5µs/call
889 |  |  |  |  |
890 | 2 | 8µs | 1 | 2µs | my $dbh = $self->_dbh # spent 2µs making 1 call to DBIx::Class::Storage::DBI::_dbh
891 |  |  |  |  | or return 0;
892 |  |  |  |  |
893 | 2 | 20µs | 2 | 7µ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 {
897 | 2 | 1µs |  |  | my $self = shift;
898 |  |  |  |  |
899 | 2 | 4µs | 1 | 400ns | my $dbh = $self->_dbh or return 0; # spent 400ns making 1 call to DBIx::Class::Storage::DBI::_dbh
900 |  |  |  |  |
901 | 2 | 24µs | 4 | 133µ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 |  |  |  |  |
904 |  |  |  |  | sub ensure_connected {
905 |  |  |  |  | my ($self) = @_;
906 |  |  |  |  |
907 |  |  |  |  | unless ($self->connected) {
908 |  |  |  |  | $self->_populate_dbh;
909 |  |  |  |  | }
910 |  |  |  |  | }
911 |  |  |  |  |
912 |  |  |  |  | =head2 dbh
913 |  |  |  |  |
914 |  |  |  |  | Returns a C<$dbh> - a data base handle of class L<DBI>. The returned handle
915 |  |  |  |  | is guaranteed to be healthy by implicitly calling L</connected>, and if
916 |  |  |  |  | necessary performing a reconnection before returning. Keep in mind that this
917 |  |  |  |  | is very B<expensive> on some database engines. Consider using L</dbh_do>
918 |  |  |  |  | instead.
919 |  |  |  |  |
920 |  |  |  |  | =cut
921 |  |  |  |  |
922 |  |  |  |  | sub 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 {
935 | 22588 | 7.59ms |  |  | my $self = shift;
936 | 22588 | 45.9ms | 22588 | 79.2ms | $self->_verify_pid; # spent 79.2ms making 22588 calls to DBIx::Class::Storage::DBI::_verify_pid, avg 4µs/call
937 | 22588 | 26.5ms | 7 | 20.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
938 | 22588 | 71.3ms | 1 | 800ns | 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 {
942 | 16827 | 9.72ms |  |  | my ($self) = @_;
943 | 16827 | 25.5ms | 1 | 3µs | unless ($self->_sql_maker) { # spent 3µs making 1 call to DBIx::Class::Storage::DBI::_sql_maker
944 | 5 | 22µs | 5 | 13.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 |  |  |  |  |
946 | 5 | 28µs | 1 | 2µ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 |  |  |  |  | ||
952 | 5 | 23µs | 5 | 123µ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 | 5 | 3µs |  |  | my ($quote_char, $name_sep);
967 |  |  |  |  |
968 | 5 | 4µs |  |  | 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 |  |  |  |  |
985 | 5 | 47µs | 6 | 627µ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 |  |  |  |  | }
994 | 16827 | 54.7ms | 1 | 700ns | return $self->_sql_maker; # spent 700ns making 1 call to DBIx::Class::Storage::DBI::_sql_maker
995 |  |  |  |  | }
996 |  |  |  |  |
997 |  |  |  |  | # nothing to do by default
998 | 6 | 21µ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 {}
999 | 6 | 21µ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 {
1002 | 6 | 4µs |  |  | my ($self) = @_;
1003 |  |  |  |  |
1004 | 6 | 36µs | 1 | 1µs | my @info = @{$self->_dbi_connect_info || []}; # spent 1µs making 1 call to DBIx::Class::Storage::DBI::_dbi_connect_info
1005 | 6 | 10µs | 1 | 800ns | $self->_dbh(undef); # in case ->connected failed we might get sent here # spent 800ns making 1 call to DBIx::Class::Storage::DBI::_dbh
1006 | 6 | 17µs | 1 | 1µs | $self->_dbh_details({}); # reset everything we know # spent 1µs making 1 call to DBIx::Class::Storage::DBI::_dbh_details
1007 |  |  |  |  |
1008 | 6 | 32µs | 7 | 20.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 |  |  |  |  |
1010 | 6 | 21µs | 1 | 2µ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 |  |  |  |  |
1012 | 6 | 19µs | 6 | 25µ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
1016 | 6 | 15µs | 1 | 600ns | $self->{transaction_depth} = $self->_dbh_autocommit ? 0 : 1; # spent 600ns making 1 call to DBIx::Class::Storage::DBI::SQLite::_dbh_autocommit
1017 |  |  |  |  |
1018 | 6 | 47µs | 6 | 326µ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 {
1022 | 6 | 3µs |  |  | my $self = shift;
1023 | 6 | 2µs |  |  | my @actions;
1024 |  |  |  |  |
1025 | 6 | 20µs | 2 | 106µ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
1026 | 6 | 20µs | 6 | 139µ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 | 12 | 26µs |  |  | $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 {
1034 | 1 | 6µs | 1 | 7µ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 {
1038 | 7002 | 8.18ms |  |  | my ($self, $capname) = @_;
1039 |  |  |  |  |
1040 | 7002 | 15.1ms | 7002 | 206ms | 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
1043 | 7594 | 28.3ms | 592 | 4.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 {
1048 | 1 | 9µs | 1 | 600ns | $_[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 {
1052 | 296 | 452µs |  |  | my ($self, $capname) = @_;
1053 |  |  |  |  |
1054 | 296 | 1.54ms | 1 | 2µs | my $cap = $self->_dbh_details->{capability}{$capname}; # spent 2µs making 1 call to DBIx::Class::Storage::DBI::_dbh_details
1055 |  |  |  |  |
1056 | 296 | 165µs |  |  | unless (defined $cap) {
1057 | 1 | 19µs | 1 | 14µ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 | 1 | 500ns |  |  | $cap = 0;
1062 |  |  |  |  | }
1063 |  |  |  |  |
1064 | 1 | 4µs | 1 | 7µs | $self->set_dbms_capability ($capname, $cap); # spent 7µs making 1 call to DBIx::Class::Storage::DBI::set_dbms_capability
1065 |  |  |  |  | }
1066 |  |  |  |  |
1067 | 296 | 1.40ms |  |  | 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 {
1071 | 4 | 2µs |  |  | my $self = shift;
1072 |  |  |  |  |
1073 | 4 | 1µs |  |  | my $info;
1074 | 4 | 15µs | 1 | 1µs | unless ($info = $self->_dbh_details->{info}) { # spent 1µs making 1 call to DBIx::Class::Storage::DBI::_dbh_details
1075 |  |  |  |  |
1076 | 4 | 2µs |  |  | $info = {};
1077 |  |  |  |  |
1078 | 8 | 42µs | 8 | 18.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 | 4 | 3µs |  |  | if (defined $server_version) {
1081 | 4 | 5µs |  |  | $info->{dbms_version} = $server_version;
1082 |  |  |  |  |
1083 | 4 | 34µs | 4 | 21µ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 | 4 | 12µs |  |  | my @verparts = split (/\./, $numeric_version);
1085 | 4 | 11µs |  |  | if (
1086 |  |  |  |  | @verparts
1087 |  |  |  |  | &&
1088 |  |  |  |  | $verparts[0] <= 999
1089 |  |  |  |  | ) {
1090 |  |  |  |  | # consider only up to 3 version parts, iff not more than 3 digits
1091 | 4 | 1µs |  |  | my @use_parts;
1092 | 4 | 6µs |  |  | while (@verparts && @use_parts < 3) {
1093 | 12 | 6µs |  |  | my $p = shift @verparts;
1094 | 12 | 4µs |  |  | last if $p > 999;
1095 | 12 | 9µs |  |  | push @use_parts, $p;
1096 |  |  |  |  | }
1097 | 4 | 3µs |  |  | push @use_parts, 0 while @use_parts < 3;
1098 |  |  |  |  |
1099 | 4 | 23µs |  |  | $info->{normalized_dbms_version} = sprintf "%d.%03d%03d", @use_parts;
1100 |  |  |  |  | }
1101 |  |  |  |  | }
1102 |  |  |  |  |
1103 | 4 | 11µs | 1 | 2µs | $self->_dbh_details->{info} = $info; # spent 2µs making 1 call to DBIx::Class::Storage::DBI::_dbh_details
1104 |  |  |  |  | }
1105 |  |  |  |  |
1106 | 4 | 12µs |  |  | 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 {
1110 | 4 | 21µs | 4 | 18.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 {
1114 | 4 | 3µs |  |  | my ($self, $info) = @_;
1115 |  |  |  |  |
1116 | 8 | 85µs | 16 | 17.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 {
1120 | 13 | 11µs |  |  | my ($self) = @_;
1121 |  |  |  |  |
1122 | 13 | 72µs | 1 | 500ns | if ((not $self->_driver_determined) && (not $self->{_in_determine_driver})) { # spent 500ns making 1 call to DBIx::Class::Storage::DBI::_driver_determined
1123 | 6 | 3µs |  |  | my $started_connected = 0;
1124 | 6 | 12µs |  |  | local $self->{_in_determine_driver} = 1;
1125 |  |  |  |  |
1126 | 6 | 10µs |  |  | if (ref($self) eq __PACKAGE__) {
1127 | 6 | 2µs |  |  | my $driver;
1128 | 6 | 23µs | 2 | 98µ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
1133 | 6 | 22µs | 1 | 600ns | 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)
1142 | 6 | 14µs | 1 | 600ns | my $dsn = $self->_dbi_connect_info->[0] || $ENV{DBI_DSN} || ''; # spent 600ns making 1 call to DBIx::Class::Storage::DBI::_dbi_connect_info
1143 | 6 | 90µs | 6 | 56µs | ($driver) = $dsn =~ /dbi:([^:]+):/i; # spent 56µs making 6 calls to DBIx::Class::Storage::DBI::CORE:match, avg 9µs/call
1144 | 6 | 4µs |  |  | $driver ||= $ENV{DBI_DRIVER};
1145 |  |  |  |  | }
1146 |  |  |  |  | }
1147 |  |  |  |  |
1148 | 6 | 6µs |  |  | if ($driver) {
1149 | 6 | 7µs |  |  | my $storage_class = "DBIx::Class::Storage::DBI::${driver}";
1150 | 6 | 32µs | 6 | 2.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
1151 | 6 | 56µs | 6 | 29µs | mro::set_mro($storage_class, 'c3'); # spent 29µs making 6 calls to mro::set_mro, avg 5µs/call
1152 | 6 | 77µs |  |  | bless $self, $storage_class;
1153 | 6 | 20µs | 6 | 13µs | $self->_rebless(); # spent 13µs making 6 calls to DBIx::Class::Storage::DBI::_rebless, avg 2µs/call
1154 |  |  |  |  | }
1155 |  |  |  |  | }
1156 |  |  |  |  | }
1157 |  |  |  |  |
1158 | 6 | 16µs | 1 | 2µs | $self->_driver_determined(1); # spent 2µs making 1 call to DBIx::Class::Storage::DBI::_driver_determined
1159 |  |  |  |  |
1160 | 6 | 2µs |  |  | Class::C3->reinitialize() if DBIx::Class::_ENV_::OLD_MRO;
1161 |  |  |  |  |
1162 | 6 | 17µs | 6 | 9µs | $self->_init; # run driver-specific initializations # spent 9µs making 6 calls to DBIx::Class::Storage::DBI::_init, avg 2µs/call
1163 |  |  |  |  |
1164 | 6 | 21µs | 1 | 1µ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 |  |  |  |  |
1169 |  |  |  |  | sub _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 |  |  |  |  |
1192 |  |  |  |  | sub connect_call_do_sql {
1193 |  |  |  |  | my $self = shift;
1194 |  |  |  |  | $self->_do_query(@_);
1195 |  |  |  |  | }
1196 |  |  |  |  |
1197 |  |  |  |  | sub disconnect_call_do_sql {
1198 |  |  |  |  | my $self = shift;
1199 |  |  |  |  | $self->_do_query(@_);
1200 |  |  |  |  | }
1201 |  |  |  |  |
1202 |  |  |  |  | # override in db-specific backend when necessary
1203 |  |  |  |  | sub connect_call_datetime_setup { 1 }
1204 |  |  |  |  |
1205 |  |  |  |  | sub _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 {
1231 | 6 | 12µs |  |  | my ($self, @info) = @_;
1232 |  |  |  |  |
1233 | 6 | 3µs |  |  | $self->throw_exception("You failed to provide any connection info")
1234 |  |  |  |  | if !@info;
1235 |  |  |  |  |
1236 | 6 | 3µs |  |  | my ($old_connect_via, $dbh);
1237 |  |  |  |  |
1238 | 6 | 12µs |  |  | 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 {
1244 | 6 | 8µs |  |  | if(ref $info[0] eq 'CODE') {
1245 |  |  |  |  | $dbh = $info[0]->();
1246 |  |  |  |  | }
1247 |  |  |  |  | else {
1248 | 6 | 130µs |  |  | require DBI;
1249 | 6 | 36µs | 6 | 7.17ms | $dbh = DBI->connect(@info); # spent 7.17ms making 6 calls to DBI::connect, avg 1.19ms/call
1250 |  |  |  |  | }
1251 |  |  |  |  |
1252 | 6 | 3µs |  |  | if (!$dbh) {
1253 |  |  |  |  | die $DBI::errstr;
1254 |  |  |  |  | }
1255 |  |  |  |  |
1256 | 6 | 48µs | 2 | 175µ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 |  |  |  |  |
1258 | 6 | 83µs | 6 | 29µ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
1265 | 6 | 47µs | 6 | 10µ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 {
1283 | 6 | 4µs |  |  | my $weak_self = $_[0];
1284 | 6 | 34µs | 6 | 12µ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 {
1289 | 2 | 22µs | 2 | 4.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 |  |  |  |  | }
1297 | 6 | 117µs | 6 | 14µs | }, '__DBIC__DBH__ERROR__HANDLER__'; # spent 14µs making 6 calls to DBI::common::STORE, avg 2µs/call
1298 | 6 | 37µs | 6 | 144µ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 {
1305 | 6 | 21µs |  |  | $DBI::connect_via = $old_connect_via if $old_connect_via;
1306 | 6 | 162µs | 24 | 644µ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 |  |  |  |  |
1308 | 6 | 60µs | 8 | 116µ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 | 6 | 25µs |  |  | $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 {
1313 | 294 | 176µs |  |  | 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
1317 | 294 | 861µs | 1 | 2µs | if (! defined $self->_dbh_autocommit) { # spent 2µs making 1 call to DBIx::Class::Storage::DBI::SQLite::_dbh_autocommit
1318 |  |  |  |  | $self->ensure_connected;
1319 |  |  |  |  | }
1320 |  |  |  |  | # Otherwise simply connect or re-connect on pid changes
1321 |  |  |  |  | else {
1322 | 294 | 959µs | 294 | 4.69ms | $self->_get_dbh; # spent 4.69ms making 294 calls to DBIx::Class::Storage::DBI::_get_dbh, avg 16µs/call
1323 |  |  |  |  | }
1324 |  |  |  |  |
1325 | 294 | 2.69ms | 294 | 4.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 {
1329 | 294 | 149µs |  |  | 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 | 294 | 1.30ms |  |  | if ($self->{_in_do_block}) {
1337 |  |  |  |  | $self->_dbh->begin_work;
1338 |  |  |  |  | } else {
1339 | 588 | 7.06ms | 882 | 57.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 {
1344 | 294 | 136µs |  |  | my $self = shift;
1345 |  |  |  |  |
1346 | 294 | 691µs | 295 | 726µ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
1347 | 294 | 261µs | 1 | 600ns | $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
1351 | 294 | 460µs | 1 | 1µs | if (! $self->transaction_depth and ! $self->_dbh->FETCH('AutoCommit') ) { # spent 1µs making 1 call to DBIx::Class::Storage::DBI::SQLite::transaction_depth
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 |  |  |  |  |
1357 | 294 | 974µs | 294 | 2.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
1361 | 294 | 6.48ms | 3 | 7µ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 {
1371 | 294 | 34.8s | 295 | 34.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 |  |  |  |  |
1374 |  |  |  |  | sub 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 |  |  |  |  |
1401 |  |  |  |  | sub _exec_txn_rollback {
1402 |  |  |  |  | shift->_dbh->rollback;
1403 |  |  |  |  | }
1404 |  |  |  |  |
1405 |  |  |  |  | # generate some identical methods
1406 | 1 | 1µs |  |  | for my $meth (qw/svp_begin svp_release svp_rollback/) {
1407 | 3 | 5.17ms | 2 | 64µ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(@_);
1414 | 3 | 28µs | 3 | 5µ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) = @_;
1422 | 8019 | 48.0ms | 8019 | 8.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 {
1426 | 8019 | 10.7ms |  |  | my ($self, $op, $ident, $args) = @_;
1427 |  |  |  |  |
1428 | 8019 | 94.9ms | 25370 | 5.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 | 8019 | 6.24ms |  |  | 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 {
1435 | 11153 | 29.6ms | 7631 | 2.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 | 11153 | 14.2ms |  |  | if (my $col = $_[1]->{dbic_colname}) {
1437 | 11153 | 21.3ms |  |  | $_[1]->{sqlt_datatype} ||= $colinfos->{$col}{data_type}
1438 |  |  |  |  | if $colinfos->{$col}{data_type};
1439 | 11153 | 16.3ms |  |  | $_[1]->{sqlt_size} ||= $colinfos->{$col}{size}
1440 |  |  |  |  | if $colinfos->{$col}{size};
1441 |  |  |  |  | }
1442 | 11153 | 43.0ms |  |  | $_[1];
1443 | 8019 | 33.7ms |  |  | };
1444 |  |  |  |  |
1445 | 8019 | 20.2ms |  |  | for my $e (@{$args->[2]{bind}||[]}, @bind) {
1446 | 11158 | 26.4ms |  |  | push @final_bind, [ do {
1447 | 11158 | 28.6ms | 5 | 34µ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 |  |  |  |  | (
1455 | 10 | 46µ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 {
1463 | 11153 | 47.4ms | 11153 | 2.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 | 8019 | 148ms |  |  | ($sql, \@final_bind);
1469 |  |  |  |  | }
1470 |  |  |  |  |
1471 |  |  |  |  | sub _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 {
1487 | 8090 | 9.76ms |  |  | my ( $self, $sql, $bind ) = @_;
1488 |  |  |  |  |
1489 | 8090 | 41.6ms | 2 | 796µ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 {
1494 | 8088 | 17.4ms |  |  | my ( $self, $sql, $bind ) = @_;
1495 |  |  |  |  |
1496 | 8088 | 50.7ms | 1 | 5µ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 |  |  |  |  |
1500 | 1 | 400ns |  |  | my $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 {
1502 | 8019 | 7.55ms |  |  | my ($self, $ident, $bind) = @_;
1503 |  |  |  |  |
1504 | 8019 | 4.65ms |  |  | if (! defined $sba_compat) {
1505 | 1 | 2µs | 1 | 3µs | $self->_determine_driver; # spent 3µs making 1 call to DBIx::Class::Storage::DBI::_determine_driver
1506 | 1 | 7µs | 1 | 4µ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 | 8019 | 3.28ms |  |  | my $sba_attrs;
1513 | 8019 | 2.07ms |  |  | 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 | 8019 | 2.91ms |  |  | my @attrs;
1525 |  |  |  |  |
1526 | 8019 | 18.6ms |  |  | for (map { $_->[0] } @$bind) {
1527 | 11158 | 16.9ms |  |  | push @attrs, do {
1528 | 11158 | 16.9ms |  |  | 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
1534 | 11158 | 29.8ms | 1 | 2µs | my $cache = $self->_dbh_details->{_datatype_map_cache} ||= {}; # spent 2µs making 1 call to DBIx::Class::Storage::DBI::_dbh_details
1535 | 11158 | 12.7ms | 14 | 185µ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 | 11158 | 11.0ms |  |  | $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 | 8019 | 33.4ms |  |  | 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 {
1553 | 8019 | 15.5ms |  |  | my ($self, $op, $ident, @args) = @_;
1554 |  |  |  |  |
1555 | 8019 | 38.4ms | 8019 | 8.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
1558 | 8019 | 93.6ms | 16038 | 118s | '_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 {
1566 | 8019 | 11.9ms |  |  | my ($self, undef, $sql, $bind, $bind_attrs) = @_;
1567 |  |  |  |  |
1568 | 8019 | 24.4ms | 8019 | 34.0ms | $self->_query_start( $sql, $bind ); # spent 34.0ms making 8019 calls to DBIx::Class::Storage::DBI::_query_start, avg 4µs/call
1569 | 8019 | 33.2ms | 8019 | 652ms | my $sth = $self->_sth($sql); # spent 652ms making 8019 calls to DBIx::Class::Storage::DBI::_sth, avg 81µs/call
1570 |  |  |  |  |
1571 | 8017 | 15.3ms |  |  | for my $i (0 .. $#$bind) {
1572 | 11156 | 20.3ms |  |  | 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 {
1581 | 11156 | 99.3ms | 11156 | 37.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???
1593 | 8017 | 117s | 8017 | 117s | my $rv = $sth->execute(); # spent 117s making 8017 calls to DBI::st::execute, avg 14.5ms/call
1594 | 8017 | 3.79ms |  |  | $self->throw_exception(
1595 |  |  |  |  | $sth->errstr || $sth->err || 'Unknown error: execute() returned false, but error flags were not set...'
1596 |  |  |  |  | ) if !$rv;
1597 |  |  |  |  |
1598 | 8017 | 37.1ms | 8017 | 53.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 | 8017 | 47.9ms |  |  | 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 {
1604 | 449 | 553µs |  |  | my ($self, $source, $to_insert) = @_;
1605 |  |  |  |  |
1606 | 449 | 1.88ms | 449 | 23.4ms | my $colinfo = $source->columns_info; # spent 23.4ms making 449 calls to DBIx::Class::ResultSource::columns_info, avg 52µs/call
1607 |  |  |  |  |
1608 | 449 | 251µs |  |  | my %values;
1609 | 449 | 2.05ms |  |  | for my $col (keys %$colinfo) {
1610 | 3942 | 4.39ms |  |  | 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 | 449 | 3.54ms |  |  | \%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 {
1634 | 449 | 648µs |  |  | my ($self, $source, $to_insert) = @_;
1635 |  |  |  |  |
1636 | 449 | 2.08ms | 449 | 36.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 | 449 | 2.33ms |  |  | $to_insert = { %$to_insert, %$prefetched_values };
1641 |  |  |  |  |
1642 | 449 | 1.40ms | 449 | 13.8ms | my $col_infos = $source->columns_info; # spent 13.8ms making 449 calls to DBIx::Class::ResultSource::columns_info, avg 31µs/call
1643 | 449 | 4.34ms | 449 | 3.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 | 449 | 201µs |  |  | my %retrieve_cols;
1645 | 449 | 3.01ms | 449 | 4.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 | 3942 | 4.38ms |  |  | (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 | 2268 | 3.33ms |  |  | $retrieve_cols{$col} = scalar keys %retrieve_cols if (
1655 |  |  |  |  | $pcols{$col}
1656 |  |  |  |  | or
1657 |  |  |  |  | $col_infos->{$col}{retrieve_on_insert}
1658 |  |  |  |  | );
1659 |  |  |  |  | };
1660 |  |  |  |  |
1661 | 449 | 441µs |  |  | my ($sqla_opts, @ir_container);
1662 | 449 | 1.57ms | 296 | 42.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 |  |  |  |  |
1671 | 449 | 16.1ms | 449 | 36.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 | 449 | 6.15ms |  |  | my %returned_cols = %$to_insert;
1674 | 449 | 1.60ms |  |  | 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 | 449 | 2.66ms |  |  | if (my @missing_pri = grep { $pcols{$_} } keys %retrieve_cols) {
1687 |  |  |  |  |
1688 | 296 | 3.53ms | 296 | 1.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 |  |  |  |  |
1691 | 296 | 1.44ms | 296 | 23.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 | 296 | 404µs |  |  | $self->throw_exception( "Can't get last insert id" )
1694 |  |  |  |  | unless (@pri_values == @missing_pri);
1695 |  |  |  |  |
1696 | 296 | 726µs |  |  | @returned_cols{@missing_pri} = @pri_values;
1697 | 592 | 1.67ms |  |  | delete $retrieve_cols{$_} for @missing_pri;
1698 |  |  |  |  | }
1699 |  |  |  |  |
1700 |  |  |  |  | # if there is more left to pull
1701 | 449 | 580µs |  |  | 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 | 449 | 10.9ms |  |  | return { %$prefetched_values, %returned_cols };
1721 |  |  |  |  | }
1722 |  |  |  |  |
1723 |  |  |  |  | sub 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 |  |  |  |  |
1872 |  |  |  |  | sub _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 |  |  |  |  |
1941 |  |  |  |  | sub _dbh_execute_array {
1942 |  |  |  |  | #my ($self, $sth, $tuple_status, @extra) = @_;
1943 |  |  |  |  | return $_[1]->execute_array({ArrayTupleStatus => $_[2]});
1944 |  |  |  |  | }
1945 |  |  |  |  |
1946 |  |  |  |  | sub _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) = @_;
1976 | 845 | 9.25ms | 845 | 80.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) = @_;
1982 | 19 | 258µs | 19 | 2.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()
1992 |  |  |  |  | sub _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 |  |  |  |  | #
2033 |  |  |  |  | sub _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 |  |  |  |  | #
2047 |  |  |  |  | sub _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 {
2083 | 6706 | 4.13ms |  |  | my $self = shift;
2084 | 6706 | 56.5ms | 13412 | 9.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 |  |  |  |  |
2087 |  |  |  |  | sub _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 {
2106 | 6706 | 7.99ms |  |  | my ($self, $ident, $select, $where, $attrs) = @_;
2107 |  |  |  |  |
2108 | 6706 | 16.8ms | 6706 | 21.6ms | my $sql_maker = $self->sql_maker; # spent 21.6ms making 6706 calls to DBIx::Class::Storage::DBI::sql_maker, avg 3µs/call
2109 | 6706 | 29.4ms | 6706 | 124ms | 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 | 6706 | 65.1ms |  |  | $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 | 6706 | 7.03ms |  |  | 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 | 6706 | 7.25ms |  |  | if (defined $attrs->{rows}) {
2130 | 5 | 54µs | 5 | 22µ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 | 6706 | 2.48ms |  |  | 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 | 6706 | 17.4ms |  |  | 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)
2165 | 6706 | 26.1ms | 6706 | 571ms | $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 | 6706 | 35.4ms |  |  | 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) = @_;
2186 | 1949 | 8.58ms |  |  | return { count => '*' };
2187 |  |  |  |  | }
2188 |  |  |  |  |
2189 |  |  |  |  | sub 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 |  |  |  |  |
2206 |  |  |  |  | Handle 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 {
2211 | 4699 | 2.99ms |  |  | my $self = shift;
2212 | 4699 | 6.25ms |  |  | my ($ident, $select, $condition, $attrs) = @_;
2213 | 4699 | 47.3ms | 9398 | 261ms | 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 {
2217 | 2007 | 1.50ms |  |  | my $self = shift;
2218 | 2007 | 31.6ms | 2007 | 3.41s | my ($rv, $sth, @bind) = $self->_select(@_); # spent 3.41s making 2007 calls to DBIx::Class::Storage::DBI::_select, avg 1.70ms/call
2219 | 2007 | 38.9ms | 2007 | 25.8ms | my @row = $sth->fetchrow_array; # spent 25.8ms making 2007 calls to DBI::st::fetchrow_array, avg 13µs/call
2220 | 2007 | 8.49ms | 1566 | 3.30ms | my @nextrow = $sth->fetchrow_array if @row; # spent 3.30ms making 1566 calls to DBI::st::fetchrow_array, avg 2µs/call
2221 | 2007 | 1.28ms |  |  | 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
2225 | 2007 | 13.2ms | 2007 | 4.26ms | $sth->finish(); # spent 4.26ms making 2007 calls to DBI::st::finish, avg 2µs/call
2226 | 2007 | 12.7ms |  |  | return @row;
2227 |  |  |  |  | }
2228 |  |  |  |  |
2229 |  |  |  |  | =head2 sql_limit_dialect
2230 |  |  |  |  |
2231 |  |  |  |  | This is an accessor for the default SQL limit dialect used by a particular
2232 |  |  |  |  | storage driver. Can be overridden by supplying an explicit L</limit_dialect>
2233 |  |  |  |  | to L<DBIx::Class::Schema/connect>. For a list of available limit dialects
2234 |  |  |  |  | see L<DBIx::Class::SQLMaker::LimitDialects>.
2235 |  |  |  |  |
2236 |  |  |  |  | =head2 sth
2237 |  |  |  |  |
2238 |  |  |  |  | =over 4
2239 |  |  |  |  |
2240 |  |  |  |  | =item Arguments: $sql
2241 |  |  |  |  |
2242 |  |  |  |  | =back
2243 |  |  |  |  |
2244 |  |  |  |  | Returns 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 {
2249 | 8019 | 8.11ms |  |  | my ($self, $dbh, $sql) = @_;
2250 |  |  |  |  |
2251 |  |  |  |  | # 3 is the if_active parameter which avoids active sth re-use
2252 | 8019 | 151ms | 16044 | 667ms | 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 | 8017 | 3.27ms |  |  | $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 | 8017 | 25.5ms |  |  | $sth;
2272 |  |  |  |  | }
2273 |  |  |  |  |
2274 |  |  |  |  | sub 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 {
2280 | 8019 | 7.59ms |  |  | my ($self, $sql) = @_;
2281 | 8019 | 37.9ms | 8019 | 0s | $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 |  |  |  |  |
2284 |  |  |  |  | sub _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 |  |  |  |  |
2344 |  |  |  |  | sub 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 |  |  |  |  |
2351 |  |  |  |  | Return 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 {
2356 | 296 | 602µs |  |  | my ($self, $dbh, $source, $col) = @_;
2357 |  |  |  |  |
2358 | 592 | 10.2ms | 593 | 16.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 | 296 | 1.67ms |  |  | 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 {
2367 | 296 | 524µs |  |  | my $self = shift;
2368 | 296 | 3.13ms | 297 | 19.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 |  |  |  |  |
2379 |  |  |  |  | This API is B<EXPERIMENTAL>, will almost definitely change in the future, and
2380 |  |  |  |  | currently only used by L<::AutoCast|DBIx::Class::Storage::DBI::AutoCast> and
2381 |  |  |  |  | L<::Sybase::ASE|DBIx::Class::Storage::DBI::Sybase::ASE>.
2382 |  |  |  |  |
2383 |  |  |  |  | The default implementation returns C<undef>, implement in your Storage driver if
2384 |  |  |  |  | you need this functionality.
2385 |  |  |  |  |
2386 |  |  |  |  | Should map types from other databases to the native RDBMS type, for example
2387 |  |  |  |  | C<VARCHAR2> to C<VARCHAR>.
2388 |  |  |  |  |
2389 |  |  |  |  | Types with modifiers should map to the underlying data type. For example,
2390 |  |  |  |  | C<INTEGER AUTO_INCREMENT> should become C<INTEGER>.
2391 |  |  |  |  |
2392 |  |  |  |  | Composite types should map to the container type, for example
2393 |  |  |  |  | C<ENUM(foo,bar,baz)> becomes C<ENUM>.
2394 |  |  |  |  |
2395 |  |  |  |  | =cut
2396 |  |  |  |  |
2397 |  |  |  |  | sub _native_data_type {
2398 |  |  |  |  | #my ($self, $data_type) = @_;
2399 |  |  |  |  | return undef
2400 |  |  |  |  | }
2401 |  |  |  |  |
2402 |  |  |  |  | # Check if placeholders are supported at all
2403 |  |  |  |  | sub _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 |  |  |  |  | #
2422 |  |  |  |  | sub _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 |  |  |  |  |
2440 |  |  |  |  | Returns 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 {
2445 | 4 | 70µs | 12 | 50µ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 |  |  |  |  |
2450 |  |  |  |  | Given a datatype from column info, returns a database specific bind
2451 |  |  |  |  | attribute for C<< $dbh->bind_param($val,$attribute) >> or nothing if we will
2452 |  |  |  |  | let the database planner just handle it.
2453 |  |  |  |  |
2454 |  |  |  |  | Generally only needed for special case column types, like bytea in postgres.
2455 |  |  |  |  |
2456 |  |  |  |  | =cut
2457 |  |  |  |  |
2458 |  |  |  |  | sub bind_attribute_by_data_type {
2459 |  |  |  |  | return;
2460 |  |  |  |  | }
2461 |  |  |  |  |
2462 |  |  |  |  | =head2 is_datatype_numeric
2463 |  |  |  |  |
2464 |  |  |  |  | Given a datatype from column_info, returns a boolean value indicating if
2465 |  |  |  |  | the current RDBMS considers it a numeric value. This controls how
2466 |  |  |  |  | L<DBIx::Class::Row/set_column> decides whether to mark the column as
2467 |  |  |  |  | dirty - when the datatype is deemed numeric a C<< != >> comparison will
2468 |  |  |  |  | be 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 |  |  |  |  |
2475 | 3 | 1µs |  |  | return 0 unless $_[1];
2476 |  |  |  |  |
2477 | 3 | 44µs | 3 | 16µ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 |  |  |  |  |
2491 |  |  |  |  | Creates a SQL file based on the Schema, for each of the specified
2492 |  |  |  |  | database engines in C<\@databases> in the given directory.
2493 |  |  |  |  | (note: specify L<SQL::Translator> names, not L<DBI> driver names).
2494 |  |  |  |  |
2495 |  |  |  |  | Given a previous version number, this will also create a file containing
2496 |  |  |  |  | the ALTER TABLE statements to transform the previous schema into the
2497 |  |  |  |  | current one. Note that these statements may contain C<DROP TABLE> or
2498 |  |  |  |  | C<DROP COLUMN> statements that can potentially destroy data.
2499 |  |  |  |  |
2500 |  |  |  |  | The file names are created using the C<ddl_filename> method below, please
2501 |  |  |  |  | override this method in your schema if you would like a different file
2502 |  |  |  |  | name format. For the ALTER file, the same format is used, replacing
2503 |  |  |  |  | $version in the name with "$preversion-$version".
2504 |  |  |  |  |
2505 |  |  |  |  | See L<SQL::Translator/METHODS> for a list of values for C<\%sqlt_args>.
2506 |  |  |  |  | The most common value for this would be C<< { add_drop_table => 1 } >>
2507 |  |  |  |  | to have the SQL produced include a C<DROP TABLE> statement for each table
2508 |  |  |  |  | created. For quoting purposes supply C<quote_table_names> and
2509 |  |  |  |  | C<quote_field_names>.
2510 |  |  |  |  |
2511 |  |  |  |  | If 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 |  |  |  |  |
2525 |  |  |  |  | By default, C<\%sqlt_args> will have
2526 |  |  |  |  |
2527 |  |  |  |  | { add_drop_table => 1, ignore_constraint_names => 1, ignore_index_names => 1 }
2528 |  |  |  |  |
2529 |  |  |  |  | merged with the hash passed in. To disable any of those features, pass in a
2530 |  |  |  |  | hashref like the following
2531 |  |  |  |  |
2532 |  |  |  |  | { ignore_constraint_names => 0, # ... other options }
2533 |  |  |  |  |
2534 |  |  |  |  |
2535 |  |  |  |  | WARNING: You are strongly advised to check all SQL files created, before applying
2536 |  |  |  |  | them.
2537 |  |  |  |  |
2538 |  |  |  |  | =cut
2539 |  |  |  |  |
2540 |  |  |  |  | sub 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 |  |  |  |  |
2683 |  |  |  |  | Returns the statements used by L</deploy> and L<DBIx::Class::Schema/deploy>.
2684 |  |  |  |  |
2685 |  |  |  |  | The L<SQL::Translator> (not L<DBI>) database driver name can be explicitly
2686 |  |  |  |  | provided in C<$type>, otherwise the result of L</sqlt_type> is used as default.
2687 |  |  |  |  |
2688 |  |  |  |  | C<$directory> is used to return statements from files in a previously created
2689 |  |  |  |  | L</create_ddl_dir> directory and is optional. The filenames are constructed
2690 |  |  |  |  | from L<DBIx::Class::Schema/ddl_filename>, the schema name and the C<$version>.
2691 |  |  |  |  |
2692 |  |  |  |  | If no C<$directory> is specified then the statements are constructed on the
2693 |  |  |  |  | fly using L<SQL::Translator> and C<$version> is ignored.
2694 |  |  |  |  |
2695 |  |  |  |  | See 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 {
2700 | 4 | 5µs |  |  | my ($self, $schema, $type, $version, $dir, $sqltargs) = @_;
2701 | 4 | 15µs | 4 | 10µs | $type ||= $self->sqlt_type; # spent 10µs making 4 calls to DBIx::Class::Storage::DBI::sqlt_type, avg 2µs/call
2702 | 4 | 28µs | 4 | 29µs | $version ||= $schema->schema_version || '1.x'; # spent 29µs making 4 calls to DBIx::Class::Schema::schema_version, avg 7µs/call
2703 | 4 | 2µs |  |  | $dir ||= './';
2704 | 4 | 19µs | 4 | 279µ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
2705 | 4 | 48µs | 4 | 33µ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 |  |  |  |  |
2716 | 4 | 24µs | 4 | 31.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 | 4 | 4µs |  |  | $sqltargs->{parser_args}{sources} = delete $sqltargs->{sources}
2723 |  |  |  |  | if exists $sqltargs->{sources};
2724 |  |  |  |  |
2725 | 4 | 31µs | 4 | 6.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 | 4 | 1µs |  |  | my @ret;
2733 | 4 | 51µs | 4 | 197ms | 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 | 4 | 2µs |  |  | $self->throw_exception( 'Unable to produce deployment statements: ' . $tr->error)
2741 |  |  |  |  | unless (@ret && defined $ret[0]);
2742 |  |  |  |  |
2743 | 4 | 42µs |  |  | 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 {
2749 | 4 | 5µ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 {
2751 | 79 | 290µs |  |  | my $line = shift;
2752 | 79 | 47µs |  |  | return if(!$line);
2753 | 79 | 1.06ms | 79 | 430µ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);
2755 | 79 | 688µs | 79 | 194µs | return if($line =~ /^BEGIN TRANSACTION/m); # spent 194µs making 79 calls to DBIx::Class::Storage::DBI::CORE:match, avg 2µs/call
2756 | 75 | 636µs | 75 | 156µs | return if($line =~ /^COMMIT/m); # spent 156µs making 75 calls to DBIx::Class::Storage::DBI::CORE:match, avg 2µs/call
2757 | 71 | 1.15ms | 71 | 695µ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
2758 | 71 | 358µs | 71 | 1.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)
2762 | 142 | 3.88ms | 213 | 23.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}")};
2765 | 71 | 2.50ms | 142 | 7.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
2766 | 71 | 1.36ms | 71 | 1.22ms | $self->_query_end($line); # spent 1.22ms making 71 calls to DBIx::Class::Storage::DBI::_query_end, avg 17µs/call
2767 | 4 | 16µs |  |  | };
2768 | 4 | 77µs | 4 | 256ms | 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 | 4 | 141µs |  |  | if (@statements > 1) {
2770 |  |  |  |  | foreach my $statement (@statements) {
2771 | 79 | 514µs | 79 | 7.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 |  |  |  |  |
2784 |  |  |  |  | Returns 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 {
2789 | 294 | 243µs |  |  | my $self = shift;
2790 | 294 | 1.83ms | 1 | 3µs | return $self->{datetime_parser} ||= do { # spent 3µs making 1 call to DBIx::Class::Storage::DBI::build_datetime_parser
2791 |  |  |  |  | $self->build_datetime_parser(@_);
2792 |  |  |  |  | };
2793 |  |  |  |  | }
2794 |  |  |  |  |
2795 |  |  |  |  | =head2 datetime_parser_type
2796 |  |  |  |  |
2797 |  |  |  |  | Defines the datetime parser class - currently defaults to L<DateTime::Format::MySQL>
2798 |  |  |  |  |
2799 |  |  |  |  | =head2 build_datetime_parser
2800 |  |  |  |  |
2801 |  |  |  |  | See 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 {
2806 | 1 | 400ns |  |  | my $self = shift;
2807 | 1 | 2µs | 1 | 2µs | my $type = $self->datetime_parser_type(@_); # spent 2µs making 1 call to DBIx::Class::Storage::DBI::datetime_parser_type
2808 | 1 | 4µs |  |  | return $type;
2809 |  |  |  |  | }
2810 |  |  |  |  |
2811 |  |  |  |  |
2812 |  |  |  |  | =head2 is_replicating
2813 |  |  |  |  |
2814 |  |  |  |  | A boolean that reports if a particular L<DBIx::Class::Storage::DBI> is set to
2815 |  |  |  |  | replicate from a master database. Default is undef, which is the result
2816 |  |  |  |  | returned by databases that don't support replication.
2817 |  |  |  |  |
2818 |  |  |  |  | =cut
2819 |  |  |  |  |
2820 |  |  |  |  | sub is_replicating {
2821 |  |  |  |  | return;
2822 |  |  |  |  |
2823 |  |  |  |  | }
2824 |  |  |  |  |
2825 |  |  |  |  | =head2 lag_behind_master
2826 |  |  |  |  |
2827 |  |  |  |  | Returns a number that represents a certain amount of lag behind a master db
2828 |  |  |  |  | when a given storage is replicating. The number is database dependent, but
2829 |  |  |  |  | starts at zero and increases with the amount of lag. Default in undef
2830 |  |  |  |  |
2831 |  |  |  |  | =cut
2832 |  |  |  |  |
2833 |  |  |  |  | sub 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 |  |  |  |  |
2845 |  |  |  |  | L<DBIx::Class> uses L<DBIx::Class::Relationship> names as table aliases in
2846 |  |  |  |  | queries.
2847 |  |  |  |  |
2848 |  |  |  |  | This hook is to allow specific L<DBIx::Class::Storage> drivers to change the
2849 |  |  |  |  | way these aliases are named.
2850 |  |  |  |  |
2851 |  |  |  |  | The default behavior is C<< "$relname_$join_count" if $join_count > 1 >>,
2852 |  |  |  |  | otherwise 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 {
2857 | 294 | 270µs |  |  | my ($self, $relname, $join_count) = @_;
2858 |  |  |  |  |
2859 | 294 | 152µs |  |  | my $alias = ($join_count && $join_count > 1 ?
2860 |  |  |  |  | join('_', $relname, $join_count) : $relname);
2861 |  |  |  |  |
2862 | 294 | 784µs |  |  | 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.
2868 |  |  |  |  | sub _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
2913 |  |  |  |  | sub _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 |  |  |  |  |
2921 |  |  |  |  | sub _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 |  |  |  |  |
2927 |  |  |  |  | sub _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 |  |  |  |  |
2934 | 1 | 29µs |  |  | 1;
2935 |  |  |  |  |
2936 |  |  |  |  | =head1 USAGE NOTES
2937 |  |  |  |  |
2938 |  |  |  |  | =head2 DBIx::Class and AutoCommit
2939 |  |  |  |  |
2940 |  |  |  |  | DBIx::Class can do some wonderful magic with handling exceptions,
2941 |  |  |  |  | disconnections, and transactions when you use C<< AutoCommit => 1 >>
2942 |  |  |  |  | (the default) combined with L<txn_do|DBIx::Class::Storage/txn_do> for
2943 |  |  |  |  | transaction support.
2944 |  |  |  |  |
2945 |  |  |  |  | If you set C<< AutoCommit => 0 >> in your connect info, then you are always
2946 |  |  |  |  | in an assumed transaction between commits, and you're telling us you'd
2947 |  |  |  |  | like to manage that manually. A lot of the magic protections offered by
2948 |  |  |  |  | this module will go away. We can't protect you from exceptions due to database
2949 |  |  |  |  | disconnects because we don't know anything about how to restart your
2950 |  |  |  |  | transactions. You're on your own for handling all sorts of exceptional
2951 |  |  |  |  | cases if you choose the C<< AutoCommit => 0 >> path, just as you would
2952 |  |  |  |  | be with raw DBI.
2953 |  |  |  |  |
2954 |  |  |  |  |
2955 |  |  |  |  | =head1 AUTHORS
2956 |  |  |  |  |
2957 |  |  |  |  | Matt S. Trout <mst@shadowcatsystems.co.uk>
2958 |  |  |  |  |
2959 |  |  |  |  | Andy Grundman <andy@hybridized.org>
2960 |  |  |  |  |
2961 |  |  |  |  | =head1 LICENSE
2962 |  |  |  |  |
2963 |  |  |  |  | You may distribute this code under the same terms as Perl itself.
2964 |  |  |  |  |
2965 | 1 | 60µs | 1 | 758µs | =cut # spent 758µs making 1 call to B::Hooks::EndOfScope::__ANON__[B/Hooks/EndOfScope.pm:26]
|  |  |  |  | # 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