Index

Symbols

!~ operator, 222

! operator, 163

!= operator, 158

$_ (topic variable) function, 90–91, 300

$ perldoc DBI, 558

$_ scalar, 223

$ sign, 52

$& variable, 240

$$ variables, 635–636

%ENV hash, 137–138

%INC hash, 139

%= operator, 151

% (modulo) operator, 166

%SIG hash, 138, 669–673

% wildcard, 741–742

& (ampersands), 350

&& operator, 163

&= operator, 152

() (parentheses), 92

* (asterisk), 262, 663

**= operator, 151

*= operator, 151

** (exponentiation) operator, 166

* (multiplication) operator, 166

+= operator, 151

+ (addition) operator, 166

-d switch, 718

-= operator, 151

- (subtraction) operator, 166

. (dot) metacharacter, 251–252

.= operator, 151

/ (forward slashes), 56, 597

/etc/passwd file, 638

/= operator, 151

/ (division) operator, 166

:: (double colons), 410

; (semicolons), 529, 726

< (less than) operator, 736, 739

<<= operator, 152

<= (less than or equal) operator, 736

<> (not equal to) operator, 736, 737

<=> (space ship) operator, 121, 130, 158

= (equal sign), 86, 503

== operator, 158

=~ operator, 222

= (equal) operator, 151, 736, 737

>>= operator, 152

> (greater than) operator, 736, 739

>= (greater than or equal) operator, 736

? (question mark), 663

? placeholder, 571–578

@ARGV array, 333–338

@_ array, passing arguments, 352–368

@INC array, 418–420, 797–802

@ISA array, 484–486

@ symbol, 52

[] (square brackets), 100, 663

(backslash), 52, 379, 597

^= operator, 152

_ (underscore), 743

{} (curly braces), 100, 265

|= operator, 152

|| operator, 163

A

abs function, 675

accept function, 675

accessing

databases, 521

directories, 608–612

elements

arrays, 95–97

slicing, 98–99

files, modifying, 620–621

hash values, 101–102

accounts, SAM (Security Accounts Manager), 639

ActivePerl, 8

adding

columns, 554

elements, arrays, 105

entries, 579

multiple records, 573

primary keys, 555

tables, primary keys, 543–544

addition (+) operator, 166

addresses

blessings, 455

memory, 380, 454

alarm function, 671, 672–673, 675

aliases

SQL (Structured Query Language), 758

typeglobs, references, 400–404

alphanumeric characters, 59

alternation of patterns, 273

alternative characters, 249

alternative quotes, 20, 55–59

ALTER TABLE command, 554, 748, 759

American National Standards Institute. See ANSI

ampersands (&), 350

anchored characters, 249, 269–271

AND operator, 736, 740

anonymous arrays, 382

anonymous hashes, 383

anonymous pipes, 326–333

anonymous subroutines, 393–394, 478. See also closures

anonymous variables, 382–383

ANSI (American National Standards Institute), 723

APIs (application programming interfaces), 530

appending files, 316

application programming interfaces. See APIs

applications (Dancer), 808–830

applying

CPAN Minus, 441–444

DBI (Database Independent Interface), 560–561

modules, 431–436, 798–799

multiple placeholders, 572

Perlbrew, 441–444

PPM (Perl Program Manager), 439–441

quotes, 737

architecture, client/server, 521

ARCHIVE attribute, 600

arguments

command-line, passing at, 29

methods, passing, 466

passing, 333–341

subroutines, passing, 352–368

arithmetic functions, 167–171

arithmetic operators, 166–167

arrays, 17, 81–82, 91–99

@_, passing arguments, 352–368

@ARGV, 333–338

@INC, 418–420, 797–802

@ISA, 484–486

anonymous, 382

assigning, 92–93

copying, 98–99

elements

adding, 105

modifying, 120

referencing, 95–97

removing, 106–107

replacing, 106–107

files, slurping, 302

functions, 105–125

chomp function, 111–112

chop function, 111–112

delete function, 106–107

exists function, 124

grep function, 112–114

join function, 118–119

map function, 119–121

pop function, 109–110

push function, 105

reverse function, 125

shift function, 110–111

sort function, 121–124

splice function, 107–109

split function, 114–118

unshift function, 106

hashes, 104, 387

indexes, checking values, 124

input, assigning, 311–312

lists, 385, 386

looping, 97–98

multidimensional, 99

naming, 92

output field separators, 93–94

range operators, 95

reversing, 125

rows, fetching, 564

sizing, 94–95

slicing, 98–99

sorting, 121–124

times function, 645

transforming, 119–121

variables, 92

arrow (±) operator, 382

ascending order, 130, 550

ASCII, 122, 159, 290

assigning

arrays, 92–93

hashes, 100–101

input

arrays, 311–312

hashes, 312–313

scalar variables, 307–308

numbers, 82

range operators, 95

scalar variables, 88

strings, 82

typeglobs, 412

values, 353–355

assignment operators, 151–153

assignment statements, 86–87

associativity, operators, 149–151

asterisk (*), 262, 663

atan2 function, 675

attributes, 448, 525

directories, 599–602

files, 599–602, 613

Moose, 776–795

PrintError, 567

RaiseError, 567

autodecrement operators, 172–173

autoincrement operators, 172–173

AUTOLOAD function, 369–370, 484

$AUTOLOAD function, 486–489

automatic error handling, 567

autovivification, 297

awk command, 114

B

backquotes, 52, 55, 659–660

backslash (), 52, 379, 597

barewords, 44, 58

base classes, 484, 489. See also classes

BEGIN block, 371

BETWEEN operator, 736

BETWEEN statement, 743

binary operators, 147. See also operators

bind function, 676

binding

columns, 569

parameters, 571–578

runtime, 472–476

bind_param() method, 574

bin folders, 532

binmode function, 676

bits, 173–174

bitwise logical operators, 173–175

bitwise operators, 174–175

black boxes, 348

blank lines, formatting, 503

bless function, 455, 676

blessings, 454

blocks, 182–187

BEGIN, 371

END, 371

Boolean context, 38

Boolean types, 153

bracket expressions (POSIX), 257–258

break statements, 204

build() method, 459

built-in functions, 3, 596

arithmetic, 168

scripts, 39–40

bytecode, 2

C

C, 3

C++, 3

caches, queries, 577–578

call-by-references, 353

caller function, 676

calling

functions, 473

methods, 473, 484–486

processes, 629

subroutines, 349–352, 410

system calls, 595–629. See also system calls

capturing

patterns, 276–279

turning off, 281

Carp module, 665–666

Carp.pm module, 428–430

case sensitivity, 86

databases, 529

SQL (Structured Query Language), 727

catching signals, 669

categories (Perl), 11

CategoryID key, 756

C dependencies, 805–806

CGIs (Common Gateway Interfaces), 522, 585, 807

here documents, 67

modules, 711

characters

alphanumeric, 59

classes, 253–256

conversion, 69

delimiters, 220

globbing, 663–664

metacharacters, 220, 245–296. See also metacharacters

sigils, 85

special, 53

whitespace, 249

char data type, 81

charts, flow, 162

chdir function, 607–608, 676

checkers, data, 469

checking syntax, 46

child processes, 629, 649

chmod command, 43

chmod function, 614–615, 676

chomp function, 43, 111–112, 308–309, 676

chop function, 111–112, 308–309, 677

chown function, 615, 677

chr function, 120, 677

Christianson, Tom, 449

chroot function, 677

classes, 450, 453–454, 459

base, 489

characters, 253–256

creating, 30

DBI (Database Independent Interface), 558–560

defining, 448–449

derived, 489–496

methods, 457. See also methods

parent, 489

SUPER pseudo, 499–501

UNIVERSAL, 484

clauses

FROM, 546

GROUP BY, 763

JOIN, 551–552

LIMIT, 550, 734

ORDER BY, 550, 744

WHERE, 548–550, 736

clients

databases, 521–522

MySQL, 532

closedir function, 610, 677

close function, 677

closing filehandles, 299

closures

defining, 478–480

objects, 481–484

clustering patterns, 273–275

cmp operator, 132, 159

Cobb, E. F. “Ted,” 723

code, threaded, 2

coercion, 148

columns, 524, 525

adding, 554

binding, 569

dropping, 555

selecting by, 546, 732

combining arrays and hashes, 104

command-lines

arguments, passing at, 29

MS-DOS, 605. See also Windows

mysql, 724

switches, 44–47, 716–717

testing, 45

UNIX, 41

commands. See also functions

ALTER TABLE, 554

awk, 114

chmod, 43

cpan, 802–803

CREATE DATABASE, 540–541

CREATE TABLE statement, 541–543

date, 57

debugging, 720–722

DELETE, 552–553

DESCRIBE, 543, 730–731

DROP DATABASE, 555

drop database, 761

EXTRACT, 769

INSERT, 745–746

INSERT statement, 544–546

interpreters, 45

LIKE, 530

ls, 599

net.exe, 639

NOT LIKE, 530

pod, 504–505

pwd, 55

QUIT, 529

SELECT, 546–547, 731–745

SHOW, 543, 730–731

show, 537

show database, 538

show databases, 728

SQL (Structured Query Language), 539–540, 725–728

start, 654–655

substitution, 53, 659–660

system calls, 595

touch, 620

UPDATE, 553–554, 746–747

USE, 529, 728

WHERE clause, 548–550

comments, 16

scripts, 38–39

commit() method, 583–585

Common Gateway Interfaces. See CGIs

comparing operands, 154

compiler directives, 84. See also pragmas

compiling programs, 412, 421

complex data structures, 104

components of relational databases, 522–527

compound statements, 182–187

conditional operators, 156–157

conditionals, 21

operators, 22

configuring passwords (MySQL), 533

connect function, 677

connecting

databases, 521, 561–563. See also databases

MySQL, 532–533

connect() method, 560, 561–562

consoles

mysql, 724

MySQL, editing keys, 533

constants, 18, 408. See also literals

constructors, 450, 457, 459

constructors, creating with objects, 458

constructs, 15–27

decision-making, 183–187

if, 183–184

if/else, 156, 184–185

if/else/else, 185–186

quotes, 55

qw, 92

unless, 186–187

contents, viewing modules, 428–430

context

hashes, 139–140

operators, 145–147

scripts, 38

subroutines, 366–368

continue statements, 210–212

control

loops, 25, 204–212

structures, 182–187

controlling terminals, 630

conventions

case sensitivity, 529, 727

naming, 85–86

databases, 529

SQL(Structured Query Language), 727

UNC (universal naming convention), 597

conversion characters, 69

converting strings/numbers, 148

Coordinated Universal Time (UTC), 643

c (complement) option, 289

copying arrays, 98–99

CORE namespace, 215

cos function, 677

CPAN (Comprehensive Perl Archive Network), 6–7, 408

@INC, 797–802

DBDs (database driver modules), 558

modules, 436–441

cpan command, 802–803

CPAN Minus, applying, 441–444

CPAN.pm module, 437

cpan shells, 438

CPU time, 643, 645. See also time

CREATE DATABASE command, 540–541

CREATE INDEX statement, 748

create() method, 459

CREATE TABLE statement, 541–543, 748, 751–753

cross joins, 756

crypt function, 677

-c switches, 46

curly braces ({}), 100, 265

customizing sorting, 122

D

Dancer, 585–590, 807–808

applications, 808–830

exercises, 829–830

parameters, 818–826

POST requests, 826–828

resources, 811

templates, 814–818

data, packing/unpacking, 624–629

database driver modules. See DBDs

Database Independent Interface. See DBI

databases

? placeholder, 571–578

case sensitivity, 529

commands

ALTER TABLE command, 554

CREATE TABLE statement, 541–543

DELETE command, 552–553

DROP DATABASE command, 555

INSERT statement, 544–546

JOIN clause, 551–552

SELECT command, 546–547

UPDATE command, 553–554

WHERE clause, 548–550

connecting, 561–563

disconnecting, 561–563

dropping, 538, 555

error messages, 567–570

formatting, 538, 748–749

interfaces, modules, 713

MySQL, 519–594. See also MySQL

naming, 529

schemas, 527

searching, 537–538

servers, 523

SQL (Structured Query Language). See also SQL

navigating, 728–729

tables, 729–731

statements, 579–582

syntax, 528–530

tables, 523–524

adding, 543–544

sorting, 550–551

transactions, 583–590

USE statements, 541

Databases Demystified, 520

data checkers, 469

Data Definition Language. See DDL

Data::Dumper module, 384

data encapsulation, 448, 450

DATA filehandles, 223–225

_ _DATA_ _ literal, 63, 64

Data Manipulation Language. See DML

data structures, inodes, 599, 621

data types, 81–87

arrays, 91–99

assignment statements, 86–87

complex data structures, 104

hashes, 99–104

naming conventions, 85–86

packages, 82–85

scalar variables, 87–91

scope, 82–85

SQL (Structured Query Language), 749–750

date and time functions, 766–770

date command, 57

DBDs (database driver modules), 556

installing, 556–558

DBI (Database Independent Interface), 556–578

applying, 560–561

class methods, 558–560

dbmclose function, 678

dbmopen function, 678

DDL (Data Definition Language), 748–761

debugging, 718–722

commands, 720–722

exiting, 719–720

script errors, 43–44

starting, 719–720

decision-making constructs, 183–187

declaring

forward declarations, 351

packages, 410

subroutines, 349

default databases, 534. See also databases

defined function, 89, 349, 678

defining

classes, 448–449

closures, 478–480

lexical variables, 83

methods, 456

objects, 447–448

subroutines, 122, 349–352

DELETE command, 552–553

delete function, 17, 18, 106–107, 135–136, 678

DELETE statement, 560, 747–748

deleting

directories, 607

duplicates

arrays, 121

hashes, 103–104

entries, 580

newlines, 111–112

delimiters, 220

global change, 232

substitution, modifying, 234

DELIMITER statement, 114, 118

deposit() method, 448

dereferencing pointers, 379

derived classes, 489–496

descendants, 629

descending order, 134, 550

DESCRIBE command, 543, 730–731

DESTROY method, 476

destructors, 450, 476–478

diagnostics, 31

errors, 567

diagnostics pragma, 76–77

die function, 299–300, 665, 678

digits, metacharacters, 248

digraph operators, 100

directives, compilers, 84. See also pragmas

directories, 597–612

accessing, 608–612

attributes, 599–602

creating, 605–607

deleting, 607

modifying, 607–608

passwords, 638–639

searching, 603–605

UNIX, 609

DIRECTORY attribute, 600

disconnecting databases, 561–563

disconnect() method, 561, 563

DISTINCT keyword, 733

distributions (Perl), 6–9

division (/) operator, 166

DML (Data Manipulation Language), 731–748

documentation

modules, 501–508, 596

MySQL, 531, 539

online, 12

Perl, 9–12

text, translating pod, 506–508

documents, here, 19, 66–68

do function, 678

do() method, 579

d (delete) option, 288

dot (.) metacharacter, 251–252

double colons (::), 410

double data type, 81

double quotes, 52, 53–54

do/until loops, 194–196

do-while loops, 24

do/while loops, 194–196

downloading Perl, 6–9

DROP DATABASE command, 555

drop database command, 761

DROP INDEX statement, 748

dropping

columns, 555

databases, 538, 555

tables, 555

DROP TABLE statement, 748, 761

dump function, 679

duplicates

arrays, removing, 121

hashes, removing, 103–104, 129

E

each function, 18, 128–129, 679

editing, 85

files, 340–341

keys, 533

editors

text, selecting, 34–35

third-party, 34

types of, 35

effective guids. See guids

effective uids. See euids

elements

arrays

adding, 105

modifying, 120

referencing, 95–97

removing, 106–107

replacing, 106–107

values, searching, 112–114

e modifier, 238

encapsulation, data, 448, 450

END block, 371

_ _END_ _ literal, 63, 64

entries

adding, 579

deleting, 580

updating, 581

environments, processes, 632–633

eof function, 338–340, 679

eq operator, 159

equality operators, 157–160

equal sign (=), 86, 503

equal to (=) operator, 736, 737

error handling, 664–669, 711

error messages

HTTP (Hypertext Transfer Protocol), 585

SQL (Structured Query Language), 567–570

errors

scripts, 43–44

spelling, 85

syntax, 2

escape sequences, 57

string literals, 61–63

-e switches, 45

euids (effective uids), 631

eval function, 666–669, 679

evaluating expressions, 147, 150, 238

examples (Moose), 778–781

extensions, 785–791

inheritance, 791–795

exclusive or (xor) operator, 164

exec function, 652, 679

execute() method, 560

execute statement, 571

executing

hashes, 566

last statements, 357

loops, 204

rows, 564

scripts, 40–42

SQL (Structured Query Language) statements, 724–725

exercises (Dancer), 829–830

exists function, 18, 124, 136–137, 679

exit function, 654, 679

exiting debugging, 719–720

exp function, 679

exponentiation (**) operator, 166

Exporter module, 489

Exporter.pm module, 424–426, 435

exporting modules, 424–426

expressions, 147

bracket (POSIX), 257–258

evaluating, 147, 150, 238

regular, 28, 112, 219–244. See also regular expressions

extensions

languages, modules, 715

.LNK, 617

Moose examples, 785–791

passwords, 641

Win32::NetAdmin, 640

EXTRACT command, 769

F

fat comma operators, 100

fcntl function, 680

feature pragma, 74

features, state, 363

fetch_array() method, 564

fetching

results, 563–566

values, 569

fields, 524, 525

map function, creating, 303

output field separators, 93–94

File::Find module, 603

filehandles. See also files

@ARGV arrays, 333–338

closing, 299

DATA, 223–225

printing, 49–50

processes, 634–636

references, typeglobs, 402–404

scripts, 37–42

special variables, 705

STDERR, 402

STDIN, 307–333, 402

STDOUT, 402

underscore, 622

user-defined, 297–307

_ _FILE_ _ literal, 63, 64

filenames, globbing, 663–664

fileno function, 680

files, 3, 26–27, 297–346, 597–612

/etc/passwd, 638

accessing, modifying, 620–621

arguments, passing, 333–341

attributes, 599–602, 613

editing, 340–341

handling, modules, 711–712

hard/soft links, 616–620

hashes, loading, 306–307

House.pm, 465

input from, reading, 90–91

locking, 317–319

opening, 297–298

appending, 316

reading, 324–325

writing, 313–314

packing/unpacking, 624–629

passwords, 638–639

pattern matching, 241

permissions, 605, 606, 612–616

.pm packages, 420–423

pod, 502–504

reading

opening, 298

scalar assignments, 300–305

renaming, 620

scripts, 16

searching, 603–605

slurping

arrays, 302

into strings with read() function, 304

statistics, 621–623

testing, 342–343

Win32 binary, 315

File::spec module, 598

file systems, ReFS (Resilient File System), 597

filters, 326. See also pipes

input, 330–333

output, 327–329

find() function, 603

finish() method, 561

flags, modifiers, 70

float data type, 81

flock function, 317–319, 680

flow

charts, 162

loops, 204

folders, bin, 532

foreach loops, 24, 97–98, 130, 198–202

foreach modifiers, 203–204

foreign keys, 755

fork function, 649–651, 680

forks, 649

for loops, 24, 196–198

format function, 680

format specifiers, 69–70

formatting

databases, 538, 748–749

date and time, 767

directories, 605–607

fields, map function, 303

instance methods, 460–461

instructions, 503

keys, 753–755

lists from scalar variables, 114–118

MySQL passwords, 533

objects with constructors, 458

OOP (Object-Oriented Perl), 450–451, 464–472

printing

printf function, 69–74

say function, 73–74

sprintf function, 73

processes

UNIX, 649–654

Win32, 654–657

scripts, 33–37, 42–44

filehandles, 37–42

linebreaks, 35–36

numbers, 36–37

statements, 35–36, 39

strings, 36–37

switches, 44–47

whitespace, 35–36

SQL (Structured Query Language) statements, 528, 725

tables, 751–753

formline function, 680

forward declarations, 351

forward slashes (/), 56, 597

frameworks, Dancer, 585–590. See also Dancer

free-form languages, 16

FROM clause, 546

full joins, 756

functions, 25–26, 347, 675–704. See also subroutines

$_ (topic variable), 90–91

abs, 675

accept, 675

alarm, 671, 672–673, 675

arithmetic, 167–171

arrays, 105–125

chomp function, 111–112

chop function, 111–112

delete function, 106–107

exists function, 124

grep function, 112–114

join function, 118–119

map function, 119–121

pop function, 109–110

push function, 105

reverse function, 125

shift function, 110–111

sort function, 121–124

splice function, 107–109

split function, 114–118

unshift function, 106

atan2, 675

AUTOLOAD, 369–370, 484

$AUTOLOAD, 486–489

bind, 676

binmode, 676

bless, 455, 676

built-in, 3, 39–40, 596

caller, 676

calling, 473

chdir, 607–608, 676

chmod, 614–615, 676

chomp, 43, 308–309, 676

chop, 308–309, 677

chown, 615, 677

chr, 120, 677

chroot, 677

close, 677

closedir, 610, 677

connect, 677

context, 38

cos, 677

crypt, 677

d, 679

dbmclose, 678

dbmopen, 678

defined, 89, 349, 678

delete, 17, 18, 678

die, 299–300, 665, 678

do, 678

dump, 679

each, 18, 679

eof, 338–340, 679

eval, 666–669, 679

exec, 652, 679

exists, 18, 679

exit, 654, 679

exp, 679

fcntl, 680

fileno, 680

File::spec module, 598

find(), 603

flock, 317–319, 680

fork, 649–651, 680

format, 680

formline, 680

getc, 311, 680

getgrent, 681

getgrgid, 681

getgrnam, 681

gethostbyaddr, 681

gethostbyname, 681

gethostent, 681

getlogin, 635, 681

getnetbyaddr, 681

getnetbyname, 682

getnetent, 682

getpeername, 682

getpgrp, 682

getppid, 635–636, 682

getpriority, 637, 682

getprotobyname, 682

getprotobynumber, 683

getprotoent, 683

getpwent, 641, 683

getpwnam, 642, 683

getpwuid, 643, 683

getservbyname, 683

getservbyport, 684

getservent, 684

getsockname, 684

getsockopt, 684

glob, 663–664, 684

gmtime, 646, 684

goto, 684

grep, 685

has, 777–778

hashes, 125–140

delete function, 135–136

each function, 128–129

exists function, 136–137

map function, 129

values function, 126–128

hex, 685

import, 685

index, 685

int, 685

ioctl, 685

join, 685

key, 685

keys, 18

kill, 670–671, 685

last, 686

lc, 686

lcfirst, 686

length, 686

link, 618, 686

listen, 686

local, 686

localtime, 648, 686

localtime(), 40, 43, 88

lock, 686

log, 687

lstat, 600, 621–623, 687

m, 687

map, 303, 687

mkdir, 605–607, 687

msgctl, 687

msgget, 688

msgrcv, 688

msgsnd, 688

my, 688

new, 688

next, 688

no, 688

not, 688

oct, 689

open, 297–298, 689

opendir, 609, 689

ord, 689

our, 689

pack, 624–629, 690

package, 690

pgrp, 636

pipe, 690

pop, 17, 690

pos, 691

print, 43, 50, 51–52, 691

printf, 16, 50, 69–74, 691

prototype, 691

push, 17, 691

q, 691

qq, 691

quotemeta, 691

qw, 691

qx, 691

rand, 168, 692

read, 692

read(), 304, 310

readdir, 609, 692

readlink, 619

readlline, 692

readllink, 692

readpipe, 692

recv, 692

redo, 692

ref, 396, 693

remdir, 607

rename, 620, 693

require, 421, 693

reset, 693

return, 349, 693

reverse, 693

rewinddir, 611, 693

rindex, 693

rmdir, 693

s, 694

say, 16, 73–74

scalar, 694

seek, 319–322, 694

seekdir, 611, 694

select, 317, 694

semctl, 694

semget, 694

semop, 695

send, 695

setpriority, 637–638, 695

setsockopt, 695

shift, 17, 695

shmctl, 695

shmget, 695

shmread, 696

shmwrite, 696

shutdown, 696

sin, 696

sleep, 672, 696

socket, 696

socketpair, 696

sort, 17, 132, 697

splice, 17, 697

split, 697

sprintf, 73, 697

SQL (Structured Query Language), 761–770

date and time, 766–770

numeric, 762–764

string, 765

sqrt, 697

srand, 168, 697

stat, 599, 621–623, 698

string operators, 175–178

study, 698

sub, 698

sub $AUTOLOAD, 486–489

subs, 371–372

substr, 699

symlink, 619, 699

syscall, 658–659, 699

sysopen, 699

sysread, 699

syssek, 699

system, 661–662, 700

syswrite, 700

tell, 322–324, 700

telldir, 611, 700

tie, 701

tied, 701

time, 702

times, 645, 702

topic variable ($_), 300

tr, 222, 702

truncate, 702

uc, 702

ucfirst, 702

umask, 616, 702

undef, 89–90, 702

UNIVERSAL, 486–489

unlink, 618, 703

unpack, 624–629, 703

unshift, 17, 703

untie, 703

use, 421, 703

utime, 620–621, 703

values, 18, 703

vec, 704

wait, 653, 704

waitpid, 653, 704

wantarray, 367–368, 704

wanted(), 603

warn, 666, 704

Win32::Spawn, 655–656

write, 704

y, 704

funny characters. See sigils

G

garbage collection, 476–478

generating random numbers, 168

ge operator, 155

getc function, 311, 680

getgrent function, 681

getgrgid function, 681

getgrnam function, 681

gethostbyaddr function, 681

gethostbyname function, 681

gethostent function, 681

getlogin function, 635, 681

getnetbyaddr function, 681

getnetbyname function, 682

getnetent function, 682

getpeername function, 682

getpgrp function, 682

getppid function, 635–636, 682

getpriority function, 637, 682

getprotobyname function, 682

getprotobynumber function, 683

getprotoent function, 683

getpwent function, 641, 683

getpwnam function, 642, 683

getpwuid function, 643, 683

GET requests, 811, 812

getservbyname function, 683

getservbyport function, 684

getservent function, 684

getsockname function, 684

getsockopt function, 684

GET strings, 818

getters, 450

global change, 232

global match modifiers, 229

global special variables, 706–708

global variables, 349

globbing, 663–664

glob function, 663–664, 684

g modifier, 229, 236

GMT (Greenwich Mean Time), 643

gmtime function, 646, 684

Goldberg, Ian, 168

goto function, 684

goto statements, 205–109

grant tables, 536

graphical user tools (MySQL), 534–537

greater than (>) operator, 736, 739

greater than or equal (>=) operator, 736

greedy metacharacters, 261, 267–268, 280

Greenwich Mean Time. See GMT

grep function, 112–114, 685

GROUP BY clause, 763

groups

patterns, 273–275

processes, 630

gt operator, 155

guids (effective guids), 631

H

h2ph scripts, 658–659

handlers, verbs, 812

handles, 558

statements, 563–566

handling

errors, 664–669, 711

files, modules, 711–712

quotes, 576–577

hard references, 378–380

hard/soft links, files, 616–620

has function, 777–778

hashes, 18, 81–82, 99–104

%SIG, 669–673

anonymous, 383

arrays, 104, 387

assigning, 100–101

context, 139–140

duplicates, removing, 103–104, 129

files, loading, 306–307

functions, 125–140

delete function, 135–136

each function, 128–129

exists function, 136–137

map function, 129

values function, 126–128

hash of, 389

indexes, 100

input, assigning, 312–313

references, 603

rows, fetching, 566

slicing, 102–103

sorting, 130–135

special, 137–139

subroutines, passing, 355

values, accessing, 101–102

HEAD requests, 812

here documents, 19, 66–68

hex function, 685

HIDDEN attribute, 600

House.pm file, 465

HTTP (Hypertext Transfer Protocol) error messages, 585

I

IBM, SQL. See SQL

identifiers, 408

identifying versions, 9

IDEs (Integrated Development Environments), 34

if constructs, 183–184

if/else constructs, 156, 184–185

if/else/else constructs, 185–186

if/else/else statements, 22

if/else statements, 21

if modifiers, 188–189

if statements, 21

i modifier, 230, 237

import function, 685

importing

methods, creating, 435

modules, 424–426

Importing module, 426

indexes, 91, 526. See also lists

arrays, checking values, 124

hashes, 100

resource representation, 826

values, searching, 112–114

index function, 685

inheritance, 449, 450, 484–501

@ISA array, 484–486

derived classes, 489–496

methods, overriding, 499–501

Moose examples, 791–795

multiple, 489, 496–499

single, 489

init() method, 459

inline subroutines, 124

inner joins, 756

inodes, 599, 600, 621

input

arrays, assigning, 311–312

filters, 330–333

hashes, assigning, 312–313

scalar variables, assigning, 307–308

input from files, reading, 90–91

input/output. See I/O

INSERT command, 745–746

INSERT statement, 544–546, 560

installing

DBDs (database driver modules), 556–558

modules

manually, 801–802

Perlbrew, 802

MySQL, 531

instance methods, 457

formatting, 460–461

invoking, 458

parameters, passing, 467–469

instance variables, 466

instantiation, 457

instructions, formatting, 503

int data type, 81

Integrated Development Environments. See IDEs

interaction (user), invoking methods, 462–464

interfaces, 595–674. See also navigating

APIs (application programming interfaces), 530

CGIs (Common Gateway Interfaces), 522, 585, 807

databases, modules, 713

DBI (Database Independent Interface), 556–578

applying, 560–561

class methods, 558–560

error handling, 664–669

here documents, 67

MySQL Query Browser, 534

operating systems, 658–664

processes, 629–657

Query Browser (MySQL), 725

interpolative context, 38

interpreted languages, overview of, 2

interpreters

commands, 45

pod, 506

int function, 685

invoking

instance methods, 458

methods, 457, 462–464

I/O (input/output), printing, 49–50

ioctl function, 685

IS [NOT] NULL operator, 736

-i switch, 340–341

J

Java, 3

JavaScript, 2

JOIN clause, 551–552

join function, 118–119, 685

joins, 756, 757

K

key function, 685

keys

CategoryID, 756

editing, 533

foreign, 755

formatting, 753–755

hashes, 100, 130. See also hashes

primary, 526, 753–754

adding, 555

tables, 543–544

references, hashes, 603

keys function, 18

keywords, 453

DISTINCT, 733

SQL (Structured Query Language), 727

kill function, 670–671, 685

L

labels, 204

nested loops and, 208–210

languages, 2

DDL (Data Definition Language), 748–761

DML (Data Manipulation Language), 731–748

extensions, modules, 715

free-form, 16

SEQUEL (Structured English Query Language), 723

SQL (Structured Query Language). See SQL

last function, 686

last statements, 204

last statements, executing, 357

lcfirst function, 686

lc function, 686

left joins, 756

length function, 686

le operator, 155

less than (<) operator, 736, 739

less than or equal (<=) operator, 736

lexagraphical ordering, 155

lexical variables, defining, 83

lib pragma, 420

libraries, 31

modules, applying, 431–436

objects, applying, 508–512

RegExLib.com, 245–247

standard Perl 5.18 library, 417–436

LIKE command, 530

LIKE operator, 736, 741

LIMIT clause, 550, 734

limiting number of lines, 734

linebreaks

scripts, 35–36

_ _LINE_ _ literal, 63, 64

lines, limiting number of, 734

link function, 618, 686

links

hard/soft, files, 616–620

symbolic, 617

Linux

PPM (Perl Program Manager), 558

system calls, 595

list context, 366

listen function, 686

lists, 91. See also arrays

arrays, 385

of lists, 99, 386

scalar variables, creating, 114–118

separators, 93

unordered, 99–104. See also hashes

values, returning, 126–128

literals, 18

numeric, 60–61

printing, 59–66

special, 63–66

strings, 61–63

.LNK extensions, 617

loading files, hashes, 306–307

locales, modules, 714

local function, 686

localhost, 523

local operator, 358

local Perl, 801

localtime function, 648, 686

localtime() function, 40, 43, 88

local to block special variables, 705

lock function, 686

locking files, 317–319

log function, 687

logical operators, 162–164

logical word operators, 164–166

login information, 635

look around assertions, 282–285

looping

arrays, 97–98

modifiers, 202–216

loops, 23

for, 24, 196–198

control, 25, 204–212

do/until, 194–196

do-while, 24

do/while, 194–196

foreach, 24, 97–98, 130, 198–202

nested and labels, 208–210

repetition, 190–202

until, 23, 192–194

while, 23, 190–192, 223

ls command, 599

lstat function, 600, 621–623, 687

lt operator, 155

M

main package, 82

main packages, 348

management

RDBMS (relational database management systems), 521

SAM (Security Accounts Manager), 639

managers, package, 800–801

man pages, 10

manual error handling, 567

map function, 119–121, 129, 303, 687

masks, system, 616

matching

modifiers, 226

patterns, 219–244, 261–286

% wildcard, 741–742

m operator, 225–229

quotes, 53, 58

math modules, 713

memory addresses, 380, 454

messages, error, 43–44

HTTP (Hypertext Transfer Protocol), 585

SQL (Structured Query Language), 567–570

metacharacters, 220, 245–296

alternative characters, 249

anchored characters, 249, 269–271

digits, 248

dot (.), 251–252

look around assertions, 282–285

miscellaneous characters, 250

m modifier, 271–272

RegExLib.com library, 245–247

remembered characters, 250, 276–279

repeated characters, 249, 261–286

single characters, 248, 251–258

s modifier, 252

substitution, 285–290

Unicode, 290–294

whitespace characters, 249, 258–261

metasymbols, 248, 253

methods, 347, 448, 450. See also subroutines

arguments, passing, 466

bind_param(), 574

build(), 459

calling, 473, 484–486

commit(), 583–585

connect(), 560, 561–562

constructors, 459

create(), 459

DBI (Database Independent Interface), 558–560

defining, 456

deposit(), 448

DESTROY, 476

disconnect(), 561, 563

do(), 579

execute(), 560

fetch_array(), 564

finish(), 561

importing, creating, 435

init(), 459

instance, 457

formatting, 460–461

invoking, 458

passing parameters, 467–469

invoking, 457, 462–464

new(), 456

overriding, 499–501

prepare(), 560

rollback(), 583–585

set_color(), 460

set_owner(), 456, 460

set_price(), 460

shoot(), 473

speak, 457

startup(), 459

subroutines, 456–464, 459

types of, 457

view(), 448

withdraw(), 448

m function, 687

miscellaneous characters, 250

mixing types, 148–149

mkdir function, 605–607, 687

m modifier, 271–272

models, client/server, 521

modes, 606

modifiers

e, 238

flags, 70

foreach, 203–204

g, 229, 236

i, 230, 237

if, 188–189

looping, 202–216

m, 271–272

matching, 226

regular expressions, 221–225

s, 252

statements, 188–190

substitution, 235

tr, 287

unless, 189–190

while, 202–203

x, 231

modifying

directories, 607–608

elements, arrays, 120

expressions, 221

files, accessing, 620–621

global change, 232

substitution delimiters, 234

modules, 31, 407–446, 710–715

applying, 431–436, 798–799

Carp, 665–666

Carp.pm, 428–430

C dependencies, 805–806

CGIs (Common Gateway Interfaces), 711

contents, viewing, 428–430

CPAN (Comprehensive Perl Archive Network), 436–441

cpan command, 802–803

CPAN Minus, applying, 441–444

CPAN.pm, 437

Dancer. See Dancer

database interfaces, 713

Data::Dumper, 384

documentation, 501–508, 596

error handling, 711

Exporter, 489

Exporter.pm, 424–426, 435

exporting/importing, 424–426

File::Find, 603

file handling, 711–712

File::spec, 598

Importing, 426

installing manually, 801–802

language extensions, 715

locales, 714

math, 713

networks, 713–714

OOP (Object-Oriented Perl), 464–472, 714

overview of, 407–417

package managers, 800–801

Perlbrew, 441–444

programming, 710

retrieving, 438

searching, 798

Shell.pm, 660–661

SomeModule.pm, 426

standard Perl 5.18 library, 417–436

terminals, 714

text processing, 712

time, 714

Time::Piece, 644

Win32::File, 600–602, 613

Win32::NetAdmin, 640

Win32::Process, 656–657

Windows, 806

modulo (%) operator, 166

Moose, 775–796

attributes, 776–795

examples, 778–781

extensions, 785–791

inheritance, 791–795

has function, 777–778

Moo (2/3 Moose), 795

types, 781–785

m operator, 225–229

MS-DOS command line, 605. See also Windows

msgctl function, 687

msgget function, 688

msgrcv function, 688

msgsnd function, 688

multidimensional arrays, 99

multiple inheritance, 489, 496–499

multiple placeholders, 572

multiple records, adding, 573

multiplication (*) operator, 166

my function, 688

my operator, 84, 358–361

MySQL, 519–594

? placeholder, 571–578

commands, 539–540

ALTER TABLE command, 554

CREATE DATABASE command, 540–541

CREATE TABLE statement, 541–543

DELETE command, 552–553

DROP DATABASE command, 555

INSERT statement, 544–546

JOIN clause, 551–552

SELECT command, 546–547

UPDATE command, 553–554

WHERE clause, 548–550

connecting, 532–533

consoles, editing keys, 533

databases

connecting, 561–563

disconnecting, 561–563

DBI (Database Independent Interface), 556–578

applying, 560–561

class methods, 558–560

documentation, 539

error messages, 567–570

EXTRACT command, 769

graphical user tools, 534–537

installing, 531

navigating, 530–555

overview of, 519–520

privileges, 536

Query Browser, 534, 725

relational databases, 520–530

client/server databases, 521–522

components, 522–527

searching, 537–538

selecting, USE statements, 541

statements, 579–582

syntax, 528–530

tables

adding, 543–544

sorting, 550–551

terminology, 531

transactions, 583–590

mysql command-line, 724

N

named parameters, 469

namespaces, 82

CORE, 215

packages, 412

variables, 82

naming

arrays, 92

case sensitivity, 86

databases, 529

modules, 408

scripts, 35

UNC (universal naming convention), 597

naming conventions, 85–86, 727

navigating

databases, 728–729

directories/files, 597–612

error handling, 664–669

MySQL, 530–555

operating systems, 658–664

Perl, 595–674

processes, 629–657

system calls, 595–629

negative look behinds, 282

ne operator, 159

nested data structures, 383–393

nested loops and labels, 208–210

net.exe command, 639

network modules, 713–714

new function, 688

newlines

deleting, 111–112

s modifier, 252

new() method, 456

next function, 688

NICEVALUE value, 638

no function, 688

northwind databases, 524. See also databases; relational databases

not equal to (<>) operator, 736, 737

not function, 688

NOT LIKE command, 530

NOT LIKE operator, 736, 741

NOT NULL, defining as, 543

NOT operator, 736

NULL, 737–739

numbers, 19

assigning, 82

inodes, 600

random, generating, 168

scripts, 36–37

strings, converting, 148

numeric equality operators, 157–158

numeric functions, 762–764

numeric literals, 60–61

numeric values, relational operators and, 154

O

Object-Oriented Perl. See OOP

objects, 30, 450

closures, 481–484

constructors, creating with, 458

defining, 447–448

libraries, applying, 508–512

references, 454, 460

oct function, 689

online documentation, 12

OOP (Object-Oriented Perl), 447–518

classes, defining, 448–449

closures

defining, 478–480

objects, 481–484

destructors, 476–478

formats, 450–451

garbage collection, 476–478

inheritance, 484–501

methods, subroutines, 456–464

modules, 714

creating, 464–472

documentation, 501–508

objects

applying from Perl libraries, 508–512

defining, 447–448

polymorphism, 472–476

programs, 451–454

runtime binding, 472–476

terminology, 449–450

opendir function, 609, 689

open function, 297–298, 689

opening

anonymous pipes, 326–333

files, 297–298

appending, 316

reading, 298, 324–325

writing, 313–314

operands, 147

comparing, 154

smartmatch operators, 160–162

operating systems, interfaces, 658–664

operators, 20, 145–180. See also specific operators

AND, 736, 740

BETWEEN, 736

arithmetic, 166–167

arrow (±), 382

assignment, 86, 151–153

associativity, 149–151

autodecrement, 172–173

autoincrement, 172–173

backslash (), 379

bitwise, 174–175

bitwise logical, 173–175

Boolean types, 153

cmp, 132

conditional, 156–157

conditionals, 22

context, 38, 145–147

digraph, 100

equality, 157–160

equal to (=), 736, 737

expressions, evaluating, 147, 150

fat comma, 100

file testing, 342–343

greater than (>), 736, 739

greater than or equal (>=), 736

IS [NOT] NULL, 736

less than (<), 736, 739

less than or equal (<=), 736

LIKE, 736, 741

local, 358

logical, 162–164

logical word, 164–166

my, 84, 358–361

NOT, 736

not equal to (<>), 736, 737

NOT LIKE, 736, 741

OR, 736, 740

pattern binding, 222–223

precedence, 149–151

range, 95, 175

regular expressions, 225–242

g modifier, 229

i modifier, 230

m operator, 225–229

pattern binding with substitution, 232–242

s operator, 232

x modifier, 231

relational, 154–155

s, 232

scope, 357–361

smartmatch, 160–162

SQL (Structured Query Language), 736

state, 358–361

strings, 175–178

tr, 285–290

types, mixing, 148–149

XOR, 736

y, 285–290

Oppel, Andy, 520

options

c (complement), 289

command-line, 44–47

d (delete), 288

s (squeeze), 290

Oracle, 723

ORDER BY clause, 550, 744

ordered lists, 92. See also lists

ord function, 689

OR operator, 736, 740

our function, 689

output

filters, 327–329

of filters to files, sending to, 329–330

output field separators, 93–94

overriding methods, 499–501

ownership of files, 612–616

P

package function, 690

_ _PACKAGE_ _ literal, 64

packages, 82–85, 408–411, 453. See also classes

declaring, 410

main, 348

managers, 800–801

namespaces, 412

.pm files, 420–423

references, 409–411

variables, 349, 416

pack function, 624–629, 690

packing data, 624–629

pages, man, 10

parameters

binding, 571–578

Dancer, 818–826

instance methods, passing, 467–469

named, 469

parent classes, 484, 489. See also classes

parentheses (()), 92

parent methods, overriding, 499–501

parent process ids. See ppids

Parrot, 4–6

passing

arguments, 333–341

command-line, 29

methods, 466

subroutines, 352–368

parameters, instance methods, 467–469

references, 394

passwords

extensions, 641

files, 638–639

getpwent function, 641

MySQL, 533

PATHEXT environment variables, 41

pathnames, 417

pattern binding operators, 222–223

patterns

alternation, 273

capturing, 276–279

clustering, 273–275

groups, 273–275

matching, 219–244, 261–286

% wildcard, 741–742

m operator, 225–229

saving, 230–231

Perl

categories, 11

documentation, 9–12

downloading, 6–9

functions, 675–704

local, 801

modules, 710–715

navigating, 595–674

overview of, 1–2

pragmas, 708–710

Quick Start, 15–32

Strawberry, 806

users of, 3

versions, 4

PERL5LIB environment variable, 419–420

Perl 6, 4–6

Perlbrew, 441–444, 803–805

permissions, files, 605, 606, 612–616

pgids (process group ids), 636

pgrp function, 636

phpMyAdmin tool, 535–536

pids (positive integers), 629

pipe function, 690

pipes, 27, 326–333

placeholders

?, 571–578

multiple, 572

multiple records, adding, 573

.pm files, packages, 420–423

pod (Plain Old Documentation), 501–508

pointers, 29–30, 377, 379. See also references

polymorphism, 450, 472–476

pop function, 17, 109–110, 690

Portable Operating System Interface. See POSIX

pos function, 691

positive integers. See pids

positive look behinds, 282

POSIX (Portable Operating System Interface), 257–258

POST requests, 812, 826–828

ppids (parent process ids), 635–636

PPM (Perl Program Manager), 408

applying, 439–441

DBDs (database driver modules), installing, 556–558

Linux, 558

pragmas, 74–78, 417, 422, 708–710. See also modules

diagnostics, 76–77

feature, 74

lib, 420

strict, 77–78, 84, 361–364, 400

use locale, 122

warning, 75–76

warnings, 85

precedence, operators, 149–151, 164

predefined variables, 18

prepare() method, 560

primary keys, 526, 753–754

adding, 555

tables, 543–544

PrintError attribute, 567

printf function, 16, 50, 691

formatting, 69–74

print function, 43, 50, 51–52, 691

printing, 16, 49–79

filehandles, 49–50

here documents, 66–68

literals, 59–66

numeric, 60–61

special, 63–66

strings, 61–63

pragmas, 74–78

diagnostics, 76–77

feature, 74

strict, 77–78

warning, 75–76

printf function, 69–74

print function, 51–52

quotes, 52–59

say function, 73–74

sprintf function, 73

words, 51

print statements, 44

priorities of processes, 637–638

privacy, 82–85

private objects, 448. See also objects

privileges (MySQL), 536

procedures, 347. See also subroutines

processes, 3, 629–657

calling, 629

child, 629, 649

environments, 632–633

filehandles, 634–636

groups, 630

priorities, 637–638

servers, 523

signals, sending, 670

text modules, 712

time, 643–649

UNIX, 629–631, 649–654

Win32, 631–632, 654–657

process group ids. See pgids

programming modules, 710

programs

compiling, 412, 421

methods, calling, 473

Moose. See Moose

OOP (Object-Oriented Perl), 451–454

set user ID, 631

properties, 448

prototype function, 691

prototypes, 365–366

pseudo classes, SUPER, 499–501

pseudo-random numbers, 168

public objects, 448. See also objects

push function, 17, 105, 691

PUT requests, 812

pwd command, 55

Python, 2

Q

q function, 691

qq function, 691

quantifiers, 261

queries, 521, 723. See also databases; MySQL; SQL

caches, 577–578

MySQL Query Browser, 534

SQL (Structured Query Language), 725–728

Query Browser (MySQL), 725

question mark (?), 663

Quick Start (Perl), 15–32

QUIT command, 529

quotemeta function, 691

quotes, 19

alternative, 20, 55–59

applying, 737

backquotes, 55

constructs, 55

double, 53–54

handling, 576–577

here documents, 66–68

matching, 53, 58

printing, 52–59

rules, 57

single, 54

qw construct, 92

qw function, 691

qx function, 691

R

RaiseError attribute, 567

Rakudo Perl, 4–6

rand function, 168, 692

random numbers, generating, 168

range operators, 95, 175

RDBMS (relational database management systems), 521, 522, 530. See also MySQL

readdir function, 609, 692

read function, 692

read() function, 304, 310

reading

files

opening, 298, 324–325

scalar assignments, 300–305

input from files, 90–91

STDIN filehandle, 307–333

readlink function, 619

readlline function, 692

readllink function, 692

READONLY attribute, 600

readpipe function, 692

records, 524, 526

multiple, adding, 573

recv function, 692

redo function, 692

redo statements, 204, 205–209

references, 29–30, 377–405

anonymous variables, 382–383

call-by-references, 353

elements, arrays, 95–97

filehandles, typeglobs, 402–404

hard, 378–380

hashes, 603

memory addresses, 454

nested data structures, 383–393

objects, 454, 460

overview of, 377–378

strict pragma, 400

subroutines, 393–396

symbolic, 398–400

typeglobs, 400–404

variables, packages, 409–411

referents, 454, 460

ref function, 396, 693

ReFS (Resilient File System), 597

RegExLib.com library, 245–247

regular expressions, 28, 112, 219–244

metacharacters. See metacharacters

modifiers, 221–225

need for, 220–221

operators, 225–242

g modifier, 229

i modifier, 230

m operator, 225–229

pattern binding with substitution, 232–242

s operator, 232

x modifier, 231

overview of, 219–220

relational database management systems. See RDBMS

relational databases, 520–530, 723

client/server databases, 521–522

components, 522–527

relational operators, 154–155

relations, 756

remdir function, 607

remembered characters, 250, 276–279

removing

directories, 607

duplicates

arrays, 121

hashes, 103–104, 129

elements, 106–107

newlines, 111–112

rename function, 620, 693

renaming files, 620

repeated characters, 249

metacharacters, 261–286

repeating patterns, matching, 261–286

repetition, loops, 190–202

replacing elements, arrays, 106–107

representation, index resources, 826

requests, 723. See also queries

GET, 811

HEAD, 812

POST, 812, 826–828

PUT, 812

require function, 421, 693

reserved words, 453, 529, 727

reset function, 693

Resilient File System. See ReFS

resources, 825

Dancer, 811

index representation, 826

for Perl, 7–8

results

fetching, 563–566

sorting, ORDER BY clauses, 744

result sets, 525, 530

number of lines, limiting, 734

SQL (Structured Query Language), 728

retrieving modules, 438

return function, 349, 693

returning

lists, 126–128

values, 356–357

return values, 647. See also values

reverse function, 125, 693

reversing

arrays, 125

hashes, sorting, 131

rewinddir function, 611, 693

rindex function, 693

rmdir function, 693

roles, multiple inheritance, 496–499

rollback() method, 583–585

roots, 631

routines, 347. See also subroutines

rows, 526

rules, quotes, 57

runtime

binding, 472–476

modules as, 421

S

SAM (Security Accounts Manager), 639

saving

formatting, sprintf function, 73

patterns, 230–231

say function, 16, 73–74

scalar context, 139–140, 366

scalar function, 694

scalar variables, 17, 29, 81–82, 87–91, 92

input, assigning, 307–308

lists, creating, 114–118

scripts, 37–38

schemas, 527, 534

Schwartz, Randal, 2

scope, 82–85

operators, 357–361

of variables, 351–352

scripts, 2, 33–48

built-in functions, 39–40

comments, 38–39

context, 38

creating, 33–37

errors, 43–44

executing, 40–42

filehandles, 37–42

files, 16

formatting, 42–44

h2ph, 658–659

linebreaks, 35–36

Moose, 776

naming, 35

numbers, 36–37

scalar variables, 37–38

statements, 35–36, 39

strings, 36–37

switches, 44–47

system calls, 595

text editors, selecting, 34–35

whitespace, 35–36

searching

databases, 537–538

directories, 603–605

files, 603–605

modules, 798

Security Accounts Manager. See SAM

seekdir function, 611, 694

seek function, 319–322, 694

SELECT command, 546–547, 731–745

SELECT DISTINCT statement, 733

select function, 317, 694

selecting

columns, 732

by columns, 546

databases, USE statements, 541

hashes, 566

rows, 564

text editors, 34–35

semctl function, 694

semget function, 694

semicolons (;), 529, 726

semop function, 695

send function, 695

sending

output of filters to files, 329–330

signals, processes, 670

values to subroutines, 352

separate resources, 825

separators

lists, 93

output field, 93–94

SEQUEL (Structured English Query Language), 723

sequences

escape, 57

operators, associativity, 149–151

string literals, 61–63

subroutines. See subroutines

server databases, 521–522, 523

set_color() method, 460

set_owner() method, 456, 460

set_price() method, 460

setpriority function, 637–638, 695

sets, result, 525, 728

setsockopt function, 695

setters, 450

set user ID programs, 631

s function, 694

shebang lines, 41

Shell.pm module, 660–661

shells

cpan, 438

CPAN (Comprehensive Perl Archive Network), 442

metacharacters, globbing, 663–664

shift function, 17, 110–111, 695

shmctl function, 695

shmget function, 695

shmread function, 696

shmwrite function, 696

shoot() method, 473

short-circuit operators, 162–164

shortcuts, 617

SHOW command, 543, 730–731

show command, 537

show database command, 538

show databases command, 728

shutdown function, 696

sigils, 85

signals

%SIG hash, 669–673

catching, 669

processes, sending, 670

simple statements, 188–190, 221–225

sin function, 696

single characters, metacharacters, 248, 251–258

single inheritance, 489

single quotes, 52, 54

single statements, 182

sizing arrays, 94–95

sleep function, 672, 696

slicing

arrays, 98–99

hashes, 102–103

slurping files

into arrays, 302

into strings with read() function, 304

smartmatch operators, 160–162

s modifier, 252

socket function, 696

socketpair function, 696

soft links, files, 616–620

SomeModule.pm module, 426

s operator, 232

s (squeeze) option, 290

sort function, 17, 121–124, 132, 697

sorting

arrays, 121–124

hashes, 130–135

results, ORDER BY clauses, 744

tables, 550–551

space ship (<=>) operators, 121, 130, 158

speak method, 457

special characters, 53

special hashes, 137–139. See also hashes

%ENV hash, 137–138

%INC hash, 139

%SIG hash, 138

special literals, 63–66

special process variables, 635

special variables

$&, 240

filehandles, 705

global, 706–708

local to block, 705

specifiers, format, 69–70

spelling errors, 85

splice function, 17, 107–109, 697

split function, 114–118, 697

sprintf function, 73, 697

SQL (Structured Query Language), 520. See also MySQL

commands, 539–540, 725–728

CREATE DATABASE command, 540–541

databases

navigating, 728–729

syntax, 528–530

tables, 729–731

data types, 749–750

DDL. See DDL

DML. See DML

error messages, 567–570

functions, 761–770

date and time, 766–770

numeric, 762–764

string, 765

operators, 736

overview of, 723

standards, 724

statements

executing, 724–725

formatting, 725

sqrt function, 697

square brackets ([]), 100, 663

srand function, 168, 697

standard Perl 5.18 library, 417–436

standards

ANSI (American National Standards Institute), 723

SQL (Structured Query Language), 724

Unicode, 290–294

start command, 654–655

starting debugging, 719–720

startup() method, 459

state feature, 363

statements, 147

BETWEEN, 743

ALTER TABLE, 748, 759

assignment, 86–87

break, 204

compound, 182–187

continue, 210–212

CREATE INDEX, 748

CREATE TABLE, 541–543, 748, 751–753

DELETE, 560, 747–748

DELIMITER, 114, 118

DROP INDEX, 748

DROP TABLE, 748, 761

execute, 571

goto, 205–109

handles, 563–566

if, 21

if/else, 21

if/else/else, 22

INSERT, 544–546

last, 204, 357

modifiers, 188–190

MySQL, 579–582

print, 44

redo, 204, 205–209

regular expressions, 221–225

scripts, 35–36, 39

SELECT DISTINCT, 733

simple, 188–190

single, 182

SQL (Structured Query Language), 528

executing, 724–725

formatting, 725

switch, 212–216

UPDATE, 560

USE, 541

state operator, 358–361

stat function, 599, 621–623, 698

statistics, files, 621–623

stat structure, 342

STDERR filehandle, 49–50, 402

STDIN filehandle, 49–50, 307–333, 402

STDOUT filehandle, 49–50, 402

Strawberry Perl, 6, 806

streams, 49–50

strictness, 82–85

strict pragma, 77–78, 361–364

strict pragmas, 84, 400

strings, 19

assigning, 82

binding, 222–223

equality operators, 159

files, slurping, 304

functions, 765

GET, 818

literals, 61–63

numbers, converting, 148

operators, 175–178

relational operators, 155

scripts, 36–37

Structured English Query Language. See SEQUEL

Structured Query Language. See SQL

structures

control, 182–187

inodes, 599, 621

nested data, 383–393

stat, 342

study function, 698

sub $AUTOLOAD function, 486–489

sub function, 698

subprograms, 347, 409–411. See also subroutines

subroutines, 25–26, 347–375, 408

anonymous, 478. See also closures

arguments, passing, 352–368

calling, 349–352, 410

context, 366–368

declaring, 349

defining, 122, 349–352

inline, 124

methods, 456–464, 459

overview of, 348–352

references, 393–396, 394

subs function, 371–372

substitution, 232

commands, 53, 659–660

delimiters, modifying, 234

metacharacters, 285–290

modifiers, 235

pattern binding with, 232–242

substr function, 699

subtraction (-) operator, 166

superclasses, 489

SUPER pseudo classes, 499–501

superusers, 536, 631

switches, 44–47

-d, 718

-c, 46

command line, 716–717

-e, 45

-i, 340–341

-w, 46–47

switch feature, 214–216

switch statements, 212–216

symbolic links, 617

symbolic references, 378, 398–400

symbols, 408

exporting, 425

metasymbols, 248, 253

tables, 412–417

symlink function, 619, 699

syntax, 15–27

errors, 2

MySQL, 528–530

shebang lines, 41

syscall function, 658–659, 699

sysopen function, 699

sysread function, 699

syssek function, 699

SYSTEM attribute, 600

system calls, 595–629

system function, 661–662, 700

system masks, 616

syswrite function, 700

T

tables, 99, 523–524

databases, 520. See also databases; MySQL

dropping, 555

formatting, 751–753

grant, 536

JOIN clause, 551–552

joins, 757

primary keys, adding, 543–544

sorting, 550–551

SQL (Structured Query Language)

databases, 729–731

symbols, 412–417

telldir function, 611, 700

tell function, 322–324, 700

templates

Dancer, 814–818

pack/unpack functions, 624–629

terminals

controlling, 630

modules, 714

terminating SQL statements, 529, 726

terminology

MySQL, 531

OOP (Object-Oriented Perl), 449–450

ternary conditional operators, 156–157

ternary operators, 147. See also operators

testing

command-lines, 45

files, 342–343

text

comments. See comments

editors, selecting, 34–35

processes, modules, 712

third-party editors, 34

threaded code, 2

tied function, 701

tie function, 701

time

data and time functions, 766–770

files, modifying, 620–621

modules, 714

processes, 643–649

time function, 702

Time::Piece module, 644

times function, 645, 702

tools

dancer, 808

MySQL, 534–537

phpMyAdmin, 535–536

topic variable ($_) function, 300

topic variables, 90–91

touch command, 620

transactions, 583–590

transforming arrays, 119–121

translating pod documentation into text, 506–508

tr function, 222

tr operator, 285–290

troubleshooting script errors, 43–44. See also error handling

truncate function, 702

turning off

capturing, 281

greedy metacharacters, 267–268, 280

typeglobs

assigning, 412

references, 400–404

types

Boolean, 153

of context, 38

data, 81–87. See also data types

of editors, 35

of methods, 457

mixing, 148–149

Moose, 781–785

of references, 378

of time values, 643

typos, 85

U

ucfirst function, 702

uc function, 702

umask function, 616, 702

unary operators, 147. See also operators

UNC (universal naming convention), 597

undef function, 89–90, 702

underscore filehandle, 622

Unicode, metacharacters, 290–294

Uniform Resource Locators. See URLs

UNIVERSAL class, 484

UNIVERSAL function, 486–489

universal naming convention. See UNC

UNIX, 2

command-lines, 41

commands. See also commands

ls, 599

touch, 620

directories, 609

attributes, 599–600

creating, 605

files

attributes, 599–600

hard/soft links, 616–617

ownership/permissions, 612

passwords, 638–639, 641

renaming, 620

functions

chmod, 614

chown, 615

link, 618

readlink, 619

symlink, 619

umask, 616

unlink, 618

processes, 629–631

creating, 649–654

environments, 632–633

filehandles, 634–636

system calls, 595

times function, 646

unless constructs, 186–187

unless modifiers, 189–190

unlink function, 618, 703

unordered lists, 99–104. See also hashes

unpack function, 624–629, 703

unpacking data, 624–629

unshift function, 17, 106, 703

untie function, 703

until loops, 23, 192–194

UPDATE command, 553–554, 746–747

UPDATE statement, 560

updating entries, 581

URLs (Uniform Resource Locators), 811

USE command, 529, 728

use function, 421, 703

use locale pragma, 122

user-defined filehandles, 297–307

user interaction, invoking methods, 462–464

USE statement, 541

UTC (Coordinated Universal Time), 643

utime function, 620–621, 703

V

values

ASCII, 159

assigning, 353–355

elements, searching, 112–114

fetching, 569

hashes, accessing, 101–102

indexes

checking arrays, 124

searching, 112–114

indexes, searching, 112–114

lists, returning, 126–128

logical operators, 162

numeric, relational operators and, 154

return, 356–357, 647

subroutines, sending, 352

time, 643. See also time

values function, 18, 126–128, 703

variables, 17, 408

$$, 635–636

$&, 240

anonymous references, 382–383

arrays, 92

environments, 632–633

error diagnostics, 567

global, 349

hashes. See hashes

instance, 466

namespaces, 82

packages, 349, 409–411, 416

PATHEXT environment, 41

PERL5LIB environment, 419–420

predefined, 18

scalar, 17, 29, 81–82, 87–91, 92

creating lists, 114–118

scripts, 37–38

scope of, 351–352

special

filehandles, 705

global, 706–708

local to block, 705

special process, 635

topic, 90–91

vec function, 704

verbs (Dancer), 811

versions

identifying, 9

MySQL, 530

Perl, 4

viewing module contents, 428–430

view() method, 448

visibility, 409. See also scope

void context, 38

W

Wagner, David, 168

wait function, 653, 704

waitpid function, 653, 704

Wall, Larry, 1, 2, 3, 478

WAMP, 531

wantarray function, 367–368, 704

wanted() function, 603

warn function, 666, 704

warning pragma, 75–76

warnings, 46–47

warnings pragma, 85

Web servers, 522. See also servers

WHERE clause, 548–550, 736

WHICH value, 638

while loops, 23, 190–192, 223

while modifiers, 202–203

whitespace

characters, 249

metacharacters, 258–261

scripts, 35–36

WHO value, 638

wildcards

%, 741–742

_ (underscore), 743

Win32

binary files, 315

password extensions, 641

processes, 631–632, 654–657

Win32::File module, 600–602, 613

Win32::NetAdmin module, 640

Win32::Process module, 656–657

Win32::Spawn function, 655–656

Windows

alarm function, 672–673

directories

attributes, 600–602

creating, 605–607

files

attributes, 600–602, 613

hard/soft links, 617–620

ownership/permissions, 612–616

passwords, 638–639

renaming, 620

functions, chmod, 614–615

modules, 806

processes, environments, 632–633

times function, 646

withdraw() method, 448

words. See also text

logical word operators, 164–166

printing, 51

reserved, 529

strict pragma, 77–78

write function, 704

writing, 313–314. See also reading

-w switches, 46–47

X

XAMPP, 531

x modifier, 231

x= operator, 152

XOR operator, 736

xor (exclusive or) operator, 164

Y

y function, 704

y operator, 285–290

Z

zeroes, 631