text:
United Learning
Campion School is part of United Learning
United Learning is a group of schools which aims to provide excellent education to children and young people across the country.
We seek to improve the life chances of all the children and young people we serve and make it our mission to bring out the best in everyone - students, staff, parents and the wider community. We are uniquely united across both the state and the independent sectors; we make learning and improvement our focus. Together, we are one of the country's leading education providers, currently educating over 60,000 students and employing over 9,000 members of staff including over 5,000 teachers.
We provide a broad education, which prepares young people to progress in learning and to make a success of their lives. We focus sharply on the evidence of what makes it more likely that young people will progress and succeed, apply that to our practice and continue to learn and develop our schools. We make it a priority to provide teachers with excellent professional support and development, so that every child receives an excellent experience.
Through being a group, we can offer more to both staff and young people than any single school could offer alone. The growing range of outstanding group-wide activities that we can provide will mean that more young people will have truly exceptional and inspiring experiences. Already, we believe that our group contains the most developed relationships and practical interaction between independent and state schools in the country, creating benefits for all the schools involved.
United Learning Ethos and Values
Our approach is underpinned by a sense of moral purpose and commitment to doing what is right for children and young people, supporting colleagues to achieve excellence and acting with integrity in all our dealings within and beyond the organisation, in the interests of young people everywhere.
We summarise this ethos as the best in everyone. This ethos underpins our core values:
- Ambition - to achieve the best for ourselves and others
- Confidence - to have the courage of our convictions and to take risks in the right cause
- Creativity - to imagine possibilities and make them real
- Respect - of ourselves and others in all that we do
- Enthusiasm - to seek opportunity, find what is good and pursue talents and interests
- Determination - to overcome obstacles and reach success
As a single organisation, we seek to bring together the best of independent and state sectors, respecting both traditions and learning from each. We believe that each of our schools is and should be distinctive - each is committed to developing its own distinctive strengths and identity while sharing our core values as institutions which promote service, compassion and generosity. This ethos is our expression of our Christian roots, in schools which are fully inclusive and both welcome and respect students and staff of all faiths and none.
The following information is available on the United Learning website
- Annual Report and Audited Accounts
- Memorandum of Association
- Articles of Association
- Names of Charity Trustees and Members
- Funding agreement
Click here to view the United Learning Financial Accountability & Freedom of Information page
United Learning Contact Details
United Learning
Worldwide House
Thorpe Wood
Email: email@example.com


text:
Are your current displays drawing qualified leads to achieve your revenue goals?
AlphaGraphics can help! Our team of marketing professionals can help you develop a strategy that ensures all of your marketing materials present one effective, cohesive message.
Vivid, alluring graphics draw conclusions in viewers' minds. AlphaGraphics can help your event visuals narrate the right story.
When you attend a trade show, your booth, signage, and printed materials represent your brand. Each visual cue should operate cohesively toward one goal - intriguing visitors enough that they want to know more. Are your current graphics drawing qualified leads to achieve your revenue goals?
We offer everything to surpass your trade show objectives!
To improve customer interaction and response rates (and make sure the right demographic attends your show), we recommend sending targeted pre-event communications.
Select a theme. Choose something memorable that relates to your company or sales pitch.
Use special effects and audio/video. Go all out—play a relevant soundtrack, use lighting to highlight key elements, and consider adding a video kit to your display.
Two words… Free stuff. Stock up on logoed promotional items to hand out. Nothing attracts visitors like a free pen, flashlight or backpack.
Try raffles. Include a raffle ticket or a chance to win a high-value incentive in the press kit and pre-show marketing for your event.
Set measurable objectives. Worried that it's not worth the investment? Send targeted marketing to qualified leads pre-event, and track metrics so you can quantify success after the event.
Not only can AlphaGraphics amplify your trade show presence, but we'll manage the details so you can focus on your business. From planning, designing, and printing, to packaging and shipping, we'll streamline the process for you. We can even help you track and analyze response rates, providing a quality, measurable ROI for your event.
(801) 972-2900

subset: commoncrawl


text:
Durable, worn in canvas salvaged from a 1950's era US Aviator's Kit Bag has been thoughtfully reworked into a versatile carryall.
Fully lined with beige cotton canvas, this bag features a large interior pocket (9" x 11") that will comfortably hold a wallet and phone, toiletries, notebook etc. Leather boot, handles and buckle straps are made from beautiful, top grain cow hide. This leather is tough enough to last a life time, but soft and supple enough for comfort.
Metal feet on the base of the bag are great for wear and tear protection when traveling while a water resistant fiberboard interior bottom panel and a lightweight aluminum frame help to retain the bag's shape while on the go.
Features an adjustable, removable leather shoulder strap with durable metal hardware.
Bag measures approximately - 17" wide, 13" tall, 7" deep.
Much time and care is put into making every Forestbound Original one of a kind. Proudly made in the USA.


text:
Mumbai International Airport
Mumbai International Airport
Car rental
Subscribe to follow up your flight details
SpiceJet (IATA code for Mumbai International Airport: BOM) serves a huge number of customers from the surrounding regions. Given the passenger traffic and airport occupancy during certain hours, check all the necessary details about the airline you are traveling with in advance. Thus, you can save your time and make the trip enjoyable and hassle-free. Below you will find info on the terminal, security checkpoints, and boarding gates used by SpiceJet, as well as contact details.
The majority of flights operating by SpiceJet arrive at the next terminals:
Arrivals in Terminal 1, Arrivals in Terminal 2.
Check the Arriving flight from SpiceJet at Mumbai International Airport!
The following terminals at Mumbai International Airport serve departing air voyages by SpiceJet:
Departures in Terminal 1, Departures in Terminal 2.
Check the Departing flight from SpiceJet at BOM!
Please keep in mind that SpiceJet terminals at BOM are subject to changes for various reasons. They include unforeseen circumstances, repair works, security reasons, etc. It can interfere with the minimum connection times for reserved routes. So, do not forget to check your flight details before your trip and upon arrival at Mumbai International Airport.
Upon arrival at Mumbai International Airport, head to the SpiceJet terminal where your flight departs from to reach the check-in facilities. Follow the instructions provided by SpiceJet to complete the check-in procedure.
Planning your itinerary with SpiceJet to/from BOM? Using the convenient flight alert system, you will get all the necessary info about changing the flight status. Thus, you will be the first to know if the flight schedule is affected and manage your time more effectively. This alert system lets travelers and those picking up passengers keep track of the status of SpiceJet arrivals at BOM (on schedule, landed, delayed, or canceled). To receive the notifications on your smartphone, you need to do just two steps:
Subscribe to follow up your flight details
To know further details about all available routes by the largest airline at Mumbai International Airport, look at the offered destinations, their exact locations, as well as the weekly number of flights below. Moreover, you will get access to the schedule of the operated routes to choose the most suitable one.


text:
Mulch Delivery in Grass Valley, OR
If there is one tool that every home gardener and landscape artist should have in their arsenal, that would be mulch. Mulches are pretty much important in gardening and landscaping. Available in organic and inorganic varieties, mulches help solve a variety of problems in a home garden.
For one, mulching can be used to prevent the loss of moisture. Used effectively, mulches can help you save time, effort and even money toward the watering of plants. Mulches also inhibit the growth of pesky weeds by covering the soil. They can also prevent splashing, one of the leading causes of the transmission of diseases among plants. mulch delivery in Grass Valley, OR. mulch delivery in Grass Valley, OR. Gravel mulches can be used to prevent water run-off.
Organic mulches include lawn clippings, leaves, sawdust, straw, bark and wood chips. Expert gardeners should know that over time, these mulches degrade and decompose and give off several benefits to the soil. Some types of mulches encourage the growth of roots while others promote soil granulation. Others raise the pH level of the soil while others decrease it.
As such, it is worthwhile to have the pH level of the soil in your garden tested prior to the application of mulch. Mulches can also encourage the growth of microorganisms and harbour insects and rodents. That is why it is necessary to take proper precautions against these unwanted garden guests. Home gardeners and landscape artists can make their own mulch using leaves and lawn clippings. They can also ask for wood chips and barks from the local tree service company or simply opt for mulch delivery. Homeowners should know that they can also order mulch online, allowing them to reap the benefits of online shopping like convenience and savings in time. This will allow them to have ample time to prepare the garden for the application of mulches.
The key here is knowing which type of mulches are best used to serve a particular purpose. Grass clippings, for example, are best used for vegetable gardens while shredded leaves are suited for flower beds and as shrub borders. Although you may be tempted to be creative in the use of mulches for landscaping, do remember the effect of each type so you won't compromise the growth and health of the plants in your garden.
Additionally, you may want to use more of organic mulches as they hardly give off any harmful effects to the environment. If you do opt for inorganic mulches, be aware of their effects in the same way you'd use firewood. Expert gardeners, with a little research and creativity, will see that mulches can provide a good shortcut to solving several gardening and landscaping woes.


text:
Behold a new and wondrous mystery.
My ears resound to the Shepherd's song, piping no soft melody, but chanting full forth a heavenly hymn. The Angels sing. The Archangels blend their voice in harmony. The Cherubim hymn their joyful praise. The Seraphim exalt His glory. All join to praise this holy feast, beholding the Godhead here on earth, and man in heaven. He Who is above, now for our redemption dwells here below; and he that was lowly is by divine mercy raised.
Bethlehem this day resembles heaven; hearing from the stars the singing of angelic voices; and in place of the sun, enfolds within itself on every side, the Sun of justice. And ask not how: for where God wills, the order of nature yields. For He willed; He had the power; He descended; He redeemed; all things yielded in obedience to God. This day He Who is, is Born; and He Who is, becomes what He was not. For when He was God, He became man; yet not departing from the Godhead that is His. Nor yet by any loss of divinity became He man, nor through increase became He God from man; but being the Word He became flesh, His nature, because of impassability, remaining unchanged.
And so the kings have come, and they have seen the heavenly King that has come upon the earth, not bringing with Him Angels, nor Archangels, nor Thrones, nor Dominations, nor Powers, nor Principalities, but, treading a new and solitary path, He has come forth from a spotless womb.
Since this heavenly birth cannot be described, neither does His coming amongst us in these days permit of too curious scrutiny. Though I know that a Virgin this day gave birth, and I believe that God was begotten before all time, yet the manner of this generation I have learned to venerate in silence and I accept that this is not to be probed too curiously with wordy speech.
For with God we look not for the order of nature, but rest our faith in the power of Him who works.
What shall I say to you; what shall I tell you? I behold a Mother who has brought forth; I see a Child come to this light by birth. The manner of His conception I cannot comprehend.
Nature here rested, while the Will of God labored. O ineffable grace! The Only Begotten, Who is before all ages, Who cannot be touched or be perceived, Who is simple, without body, has now put on my body, that is visible and liable to corruption. For what reason? That coming amongst us he may teach us, and teaching, lead us by the hand to the things that men cannot see. For since men believe that the eyes are more trustworthy than the ears, they doubt of that which they do not see, and so He has deigned to show Himself in bodily presence, that He may remove all doubt.
Christ, finding the holy body and soul of the Virgin, builds for Himself a living temple, and as He had willed, formed there a man from the Virgin; and, putting Him on, this day came forth; unashamed of the lowliness of our nature.
For it was to Him no lowering to put on what He Himself had made. Let that handiwork be forever glorified, which became the cloak of its own Creator. For as in the first creation of flesh, man could not be made before the clay had come into His hand, so neither could this corruptible body be glorified, until it had first become the garment of its Maker.
What shall I say! And how shall I describe this Birth to you? For this wonder fills me with astonishment. The Ancient of days has become an infant. He Who sits upon the sublime and heavenly Throne, now lies in a manger. And He Who cannot be touched, Who is simple, without complexity, and incorporeal, now lies subject to the hands of men. He Who has broken the bonds of sinners, is now bound by an infants bands. But He has decreed that ignominy shall become honor, infamy be clothed with glory, and total humiliation the measure of His Goodness.
For this He assumed my body, that I may become capable of His Word; taking my flesh, He gives me His spirit; and so He bestowing and I receiving, He prepares for me the treasure of Life. He takes my flesh, to sanctify me; He gives me His Spirit that He may save me.
Come, then, let us observe the Feast. Truly wondrous is the whole chronicle of the Nativity. For this day the ancient slavery is ended, the devil confounded, the demons take to flight, the power of death is broken, paradise is unlocked, the curse is taken away, sin is removed from us, error driven out, truth has been brought back, the speech of kindliness diffused, and spreads on every side, a heavenly way of life has been ¡in planted on the earth, angels communicate with men without fear, and men now hold speech with angels.
Why is this? Because God is now on earth, and man in heaven; on every side all things commingle. He became Flesh. He did not become God. He was God. Wherefore He became flesh, so that He Whom heaven did not contain, a manger would this day receive. He was placed in a manger, so that He, by whom all things are nourished, may receive an infant's food from His Virgin Mother. So, the Father of all ages, as an infant at the breast, nestles in the virginal arms, that the Magi may more easily see Him. Since this day the Magi too have come, and made a beginning of withstanding tyranny; and the heavens give glory, as the Lord is revealed by a star.
To Him, then, Who out of confusion has wrought a clear path, to Christ, to the Father, and to the Holy Spirit, we offer all praise, now and forever. Amen.
~Antiochian Orthodox Christian Archdiocese of North America, http://www.antiochian.org/node/21955.


text:
An understanding of the relevance of free casino chips must be put into its proper context: are the offers of the free chips coming from honest online casinos?
The first online casinos opened 10 years ago, and now there are hundreds that can be found online. Estimates vary as to the number of people who gamble online, but recent estimates suggest that a figure of around seven million worldwide would not be too far out. Taking that into account, and with a further estimate of more than $12 billion spent in online casinos alone (not including physical land-based casinos), offers of free casino chips may understandably be seen as something of a drop in the ocean.
Add to that the question of whether or not these free chips are being offered by honest online casinos, and we enter an area worth some study or serious research.
Firstly, let us consider what these free casino chips are really worth to the individual online casino player. Free casino chips are of four main types:
No Deposit Bonus. This is simply free money. Honest online casinos will offer free casino chips with no strings attached, simply to attract people to play at their virtual tables. There will sometimes be minor strings attached. For example, the casino may ask for credit card details up front. Always read the terms.
Matching Deposit Bonus. This is where the house will match your deposit. Often this is done in multiples. For example, a 200% bonus will mean that if you were to deposit $100 then the casino would add $200 in free casino chips to your account. Very nice! Especially useful for new players starting out.
Uncashable Bonus. This is the so-called 'sticky' bonus. This can never be cashed, but its usefulness lies in that fact that it stays in your account and enables you to use the bonus account to 'leverage' higher wagers. These free casino chips stay latent in your account simply to allow you to do things which you otherwise could not.
Loyalty Bonus. This is exactly as it sounds. All honest online casinos, and offline ones too, want to keep hold of their good returning customers, and will offer loyalty bonuses, including free casino chips, as a result.
Remember that online casinos can afford to do this because they simply do not have the overhead that their brick and mortar land-based counterparts have. Equally, there is no excuse for an online casino NOT to be honest for exactly the same reason. They can offer free casino chips AND be an honest online casino in circumstances where their physical equivalents would find the financial burden impossible.
So how do we go about identifying which are the honest online casinos and which are not? Well, a lot has changed since the earliest online casinos set up shop in their offshore locations in 1996. Self-regulation (at best dubious) led to accreditation of bodies like ECOGRA (E-Commerce Online Gaming Regulation and Assurance). Look out also for evidence of good customer care, positive feedback from online casino forum members and decent helpline facilities. The more honest online casinos will offer (will actively boast) 24 hour live chat and live email support as well as toll-free telephone help. Does it have a mailing list you can join to keep in contact with the latest tournaments and special offers? Trust lies at the heart of any subscription process (or people would not subscribe) so that in itself is a good indicator of an honest online casino.
Transparency of accounting systems is another good indicator of honest online casinos. When testimonials are published make sure that it is from more than a set of initials, and make sure they have a state or country. Free casino chips may be 'virtual' in concept, but they are used by real people!
But the best indicator of an honest online casino is by personal recommendation. This also includes affiliation of such casinos into trusted casino websites and portals. If an offer of free casino chips [http://www.gamble-on-the-internet.com/free-casino-chips-and-honest-online-casinos.htm] is made by an online casino on such a site then it can probably be trusted.


text:
Report Incorrect DataTrinitarian Monastery is located in Main St, Adare. To communicate or ask something with the place, the Phone number is +353 61 396 172. You can get more information from their website: http://www.adareparish.ie/. The coordinates that you can use in navigation applications to get to find "Trinitarian Monastery" quickly are 52.564540863037,-8.7891998291016
Details | |
Name: | Trinitarian Monastery |
Categories: | |
Phone: | +353 61 396 172 |
Website: | http://www.adareparish.ie/ |
Address: | Main St, Adare, Ireland |
References: | Foursquare |
You can review this Business and help others by leaving a comment. If you want to share your thoughts about Trinitarian Monastery, use the form below and your opinion, advice or comment will appear in this space.
© 2024 ireland724.info All Rights reserved.
At ireland724.info our purpose is to help people find great local businesses like dentists, hair stylists, restaurants, bars, hotels....
The content displayed in the ireland724.info Directory consists of information from third parties, among others from publicly accessible sources, or from customers, who have a presentation page in our directory. ireland724.info cannot be held responsible or liable for the accuracy, correctness, usefulness or reliability of the data. The brand names, logos, images and texts are the property of these third parties and their respective owners. If you have any questions or suggestions regarding this matter, you are welcome to contact our customer support team.
ireland724.info is not a booking agent, and does not charge any service fees to users of our site.
ireland724.info is not responsible for content on external web sites. Taxes, fees not included for deals content.


text:
Fleetwood Mac: "Landslide" (Unsigned Prints)
Soundwaves Artwork created from the soundwaves of Fleetwood Mac's "Landslide." Every print is hand signed by Soundwaves Art creator, Tim Wakefield. These prints are NOT signed by the band.
Mini: 12" x 12" with 2.5" white border
Standard: 24" x 24" with 3" white border
Standard: 24" x 24" with 3" white border
Each piece is hand numbered from 1 to 200 and signed by Soundwaves Art
Ships with a certificate of authenticity. "Standard" and "Mini" ship unframed. Orders for "Standard with Frame" and "Mini with Frame" may take up to 30 additional days to arrive.


text:
5. Bug Reporting Guidelines
When you find a bug in PostgreSQL we want to hear about it. Your bug reports play an important part in making PostgreSQL more reliable because even the utmost care cannot guarantee that every part of PostgreSQL will work on every platform under every circumstance.
The following suggestions are intended to assist you in forming bug reports that can be handled in an effective fashion. No one is required to follow them but doing so tends to be to everyone's advantage.
We cannot promise to fix every bug right away. If the bug is obvious, critical, or affects a lot of users, chances are good that someone will look into it. It could also happen that we tell you to update to a newer version to see if the bug happens there. Or we might decide that the bug cannot be fixed before some major rewrite we might be planning is done. Or perhaps it is simply too hard and there are more important things on the agenda. If you need help immediately, consider obtaining a commercial support contract.
5.1. Identifying Bugs
Before you report a bug, please read and re-read the documentation to verify that you can really do whatever it is you are trying. If it is not clear from the documentation whether you can do something or not, please report that too; it is a bug in the documentation. If it turns out that a program does something different from what the documentation says, that is a bug. That might include, but is not limited to, the following circumstances:
A program terminates with a fatal signal or an operating system error message that would point to a problem in the program. (A counterexample might be a " disk full " message, since you have to fix that yourself.)
A program produces the wrong output for any given input.
A program refuses to accept valid input (as defined in the documentation).
A program accepts invalid input without a notice or error message. But keep in mind that your idea of invalid input might be our idea of an extension or compatibility with traditional practice.
PostgreSQL fails to compile, build, or install according to the instructions on supported platforms.
Here " program " refers to any executable, not only the backend process.
Being slow or resource-hogging is not necessarily a bug. Read the documentation or ask on one of the mailing lists for help in tuning your applications. Failing to comply to the SQL standard is not necessarily a bug either, unless compliance for the specific feature is explicitly claimed.
Before you continue, check on the TODO list and in the FAQ to see if your bug is already known. If you cannot decode the information on the TODO list, report your problem. The least we can do is make the TODO list clearer.
5.2. What to Report
The most important thing to remember about bug reporting is to state all the facts and only facts. Do not speculate what you think went wrong, what " it seemed to do " , or which part of the program has a fault. If you are not familiar with the implementation you would probably guess wrong and not help us a bit. And even if you are, educated explanations are a great supplement to but no substitute for facts. If we are going to fix the bug we still have to see it happen for ourselves first. Reporting the bare facts is relatively straightforward (you can probably copy and paste them from the screen) but all too often important details are left out because someone thought it does not matter or the report would be understood anyway.
The following items should be contained in every bug report:
The exact sequence of steps from program start-up necessary to reproduce the problem. This should be self-contained; it is not enough to send in a bare
statement without the precedingCREATE TABLE
statements, if the output should depend on the data in the tables. We do not have the time to reverse-engineer your database schema, and if we are supposed to make up our own data we would probably miss the problem.The best format for a test case for SQL-related problems is a file that can be run through the psql frontend that shows the problem. (Be sure to not have anything in your
start-up file.) An easy way to create this file is to use pg_dump to dump out the table declarations and data needed to set the scene, then add the problem query. You are encouraged to minimize the size of your example, but this is not absolutely necessary. If the bug is reproducible, we will find it either way.If your application uses some other client interface, such as PHP , then please try to isolate the offending queries. We will probably not set up a web server to reproduce your problem. In any case remember to provide the exact input files; do not guess that the problem happens for " large files " or " midsize databases " , etc. since this information is too inexact to be of use.
The output you got. Please do not say that it " didn't work " or " crashed " . If there is an error message, show it, even if you do not understand it. If the program terminates with an operating system error, say which. If nothing at all happens, say so. Even if the result of your test case is a program crash or otherwise obvious it might not happen on our platform. The easiest thing is to copy the output from the terminal, if possible.
If you are reporting an error message, please obtain the most verbose form of the message. In psql , say
\set VERBOSITY verbose
beforehand. If you are extracting the message from the server log, set the run-time parameter log_error_verbosity toverbose
so that all details are logged.Note
In case of fatal errors, the error message reported by the client might not contain all the information available. Please also look at the log output of the database server. If you do not keep your server's log output, this would be a good time to start doing so.
The output you expected is very important to state. If you just write " This command gives me that output. " or " This is not what I expected. " , we might run it ourselves, scan the output, and think it looks OK and is exactly what we expected. We should not have to spend the time to decode the exact semantics behind your commands. Especially refrain from merely saying that " This is not what SQL says/Oracle does. " Digging out the correct behavior from SQL is not a fun undertaking, nor do we all know how all the other relational databases out there behave. (If your problem is a program crash, you can obviously omit this item.)
Any command line options and other start-up options, including any relevant environment variables or configuration files that you changed from the default. Again, please provide exact information. If you are using a prepackaged distribution that starts the database server at boot time, you should try to find out how that is done.
Anything you did at all differently from the installation instructions.
The PostgreSQL version. You can run the command
SELECT version();
to find out the version of the server you are connected to. Most executable programs also support a--version
option; at leastpostgres --version
andpsql --version
should work. If the function or the options do not exist then your version is more than old enough to warrant an upgrade. If you run a prepackaged version, such as RPMs, say so, including any subversion the package might have. If you are talking about a Git snapshot, mention that, including the commit hash.If your version is older than 12.19 we will almost certainly tell you to upgrade. There are many bug fixes and improvements in each new release, so it is quite possible that a bug you have encountered in an older release of PostgreSQL has already been fixed. We can only provide limited support for sites using older releases of PostgreSQL ; if you require more than we can provide, consider acquiring a commercial support contract.
Platform information. This includes the kernel name and version, C library, processor, memory information, and so on. In most cases it is sufficient to report the vendor and version, but do not assume everyone knows what exactly " Debian " contains or that everyone runs on x86_64. If you have installation problems then information about the toolchain on your machine (compiler, make , and so on) is also necessary.
Do not be afraid if your bug report becomes rather lengthy. That is a fact of life. It is better to report everything the first time than us having to squeeze the facts out of you. On the other hand, if your input files are huge, it is fair to ask first whether somebody is interested in looking into it. Here is an article that outlines some more tips on reporting bugs.
Do not spend all your time to figure out which changes in the input make the problem go away. This will probably not help solving it. If it turns out that the bug cannot be fixed right away, you will still have time to find and share your work-around. Also, once again, do not waste your time guessing why the bug exists. We will find that out soon enough.
When writing a bug report, please avoid confusing terminology. The software package in total is called " PostgreSQL " , sometimes " Postgres " for short. If you are specifically talking about the backend process, mention that, do not just say " PostgreSQL crashes " . A crash of a single backend process is quite different from crash of the parent " postgres " process; please don't say " the server crashed " when you mean a single backend process went down, nor vice versa. Also, client programs such as the interactive frontend " psql " are completely separate from the backend. Please try to be specific about whether the problem is on the client or server side.
5.3. Where to Report Bugs
In general, send bug reports to the bug report mailing list at
You are requested to use a descriptive subject for your email
message, perhaps parts of the error message.
Another method is to fill in the bug report web-form available
at the project's
web site
Entering a bug report this way causes it to be mailed to the
mailing list.
If your bug report has security implications and you'd prefer that it
not become immediately visible in public archives, don't send it to
. Security issues can be
reported privately to
Do not send bug reports to any of the user mailing lists, such as
These mailing lists are for answering
user questions, and their subscribers normally do not wish to receive
bug reports. More importantly, they are unlikely to fix them.
Also, please do
send reports to
the developers' mailing list
This list is for discussing the
development of
, and it would be nice
if we could keep the bug reports separate. We might choose to take up a
discussion about your bug report on
if the problem needs more review.
If you have a problem with the documentation, the best place to report it
is the documentation mailing list
Please be specific about what part of the documentation you are unhappy
If your bug is a portability problem on a non-supported platform,
send mail to
so we (and you) can work on
to your platform.
Due to the unfortunate amount of spam going around, all of the above lists will be moderated unless you are subscribed. That means there will be some delay before the email is delivered. If you wish to subscribe to the lists, please visit https://lists.postgresql.org/ for instructions.


text:
perlboot - Beginner's Object-Oriented Tutorial
If you're not familiar with objects from other languages, some of the other Perl object documentation may be a little daunting, such as perlobj, a basic reference in using objects, and perltoot, which introduces readers to the peculiarities of Perl's object system in a tutorial way.
So, let's take a different approach, presuming no prior object experience. It helps if you know about subroutines (perlsub), references (perlref et. seq.), and packages (perlmod), so become familiar with those first if you haven't already.
Let's let the animals talk for a moment:
sub Cow::speak {
print "a Cow goes moooo!\n";
sub Horse::speak {
print "a Horse goes neigh!\n";
sub Sheep::speak {
print "a Sheep goes baaaah!\n";
This results in:
a Cow goes moooo!
a Horse goes neigh!
a Sheep goes baaaah!
Nothing spectacular here. Simple subroutines, albeit from separate packages, and called using the full package name. So let's create an entire pasture:
# Cow::speak, Horse::speak, Sheep::speak as before
@pasture = qw(Cow Cow Horse Sheep Sheep);
foreach $animal (@pasture) {
This results in:
a Cow goes moooo!
a Cow goes moooo!
a Horse goes neigh!
a Sheep goes baaaah!
a Sheep goes baaaah!
Wow. That symbolic coderef de-referencing there is pretty nasty. We're counting on no strict refs
mode, certainly not recommended for larger programs. And why was that necessary? Because the name of the package seems to be inseparable from the name of the subroutine we want to invoke within that package.
Or is it?
For now, let's say that Class->method
invokes subroutine method
in package Class
. (Here, "Class" is used in its "category" meaning, not its "scholastic" meaning.) That's not completely accurate, but we'll do this one step at a time. Now let's use it like so:
# Cow::speak, Horse::speak, Sheep::speak as before
And once again, this results in:
a Cow goes moooo!
a Horse goes neigh!
a Sheep goes baaaah!
That's not fun yet. Same number of characters, all constant, no variables. But yet, the parts are separable now. Watch:
$a = "Cow";
$a->speak; # invokes Cow->speak
Ahh! Now that the package name has been parted from the subroutine name, we can use a variable package name. And this time, we've got something that works even when use strict refs
is enabled.
Let's take that new arrow invocation and put it back in the barnyard example:
sub Cow::speak {
print "a Cow goes moooo!\n";
sub Horse::speak {
print "a Horse goes neigh!\n";
sub Sheep::speak {
print "a Sheep goes baaaah!\n";
@pasture = qw(Cow Cow Horse Sheep Sheep);
foreach $animal (@pasture) {
There! Now we have the animals all talking, and safely at that, without the use of symbolic coderefs.
But look at all that common code. Each of the speak
routines has a similar structure: a print
operator and a string that contains common text, except for two of the words. It'd be nice if we could factor out the commonality, in case we decide later to change it all to says
instead of goes
And we actually have a way of doing that without much fuss, but we have to hear a bit more about what the method invocation arrow is actually doing for us.
The invocation of:
attempts to invoke subroutine Class::method
Class::method("Class", @args);
(If the subroutine can't be found, "inheritance" kicks in, but we'll get to that later.) This means that we get the class name as the first parameter (the only parameter, if no arguments are given). So we can rewrite the Sheep
speaking subroutine as:
sub Sheep::speak {
my $class = shift;
print "a $class goes baaaah!\n";
And the other two animals come out similarly:
sub Cow::speak {
my $class = shift;
print "a $class goes moooo!\n";
sub Horse::speak {
my $class = shift;
print "a $class goes neigh!\n";
In each case, $class
will get the value appropriate for that subroutine. But once again, we have a lot of similar structure. Can we factor that out even further? Yes, by calling another method in the same class.
Let's call out from speak
to a helper method called sound
. This method provides the constant text for the sound itself.
{ package Cow;
sub sound { "moooo" }
sub speak {
my $class = shift;
print "a $class goes ", $class->sound, "!\n";
Now, when we call Cow->speak
, we get a $class
of Cow
in speak
. This in turn selects the Cow->sound
method, which returns moooo
. But how different would this be for the Horse
{ package Horse;
sub sound { "neigh" }
sub speak {
my $class = shift;
print "a $class goes ", $class->sound, "!\n";
Only the name of the package and the specific sound change. So can we somehow share the definition for speak
between the Cow and the Horse? Yes, with inheritance!
We'll define a common subroutine package called Animal
, with the definition for speak
{ package Animal;
sub speak {
my $class = shift;
print "a $class goes ", $class->sound, "!\n";
Then, for each animal, we say it "inherits" from Animal
, along with the animal-specific sound:
{ package Cow;
@ISA = qw(Animal);
sub sound { "moooo" }
Note the added @ISA
array (pronounced "is a"). We'll get to that in a minute.
But what happens when we invoke Cow->speak
First, Perl constructs the argument list. In this case, it's just Cow
. Then Perl looks for Cow::speak
. But that's not there, so Perl checks for the inheritance array @Cow::ISA
. It's there, and contains the single name Animal
Perl next checks for speak
inside Animal
instead, as in Animal::speak
. And that's found, so Perl invokes that subroutine with the already frozen argument list.
Inside the Animal::speak
subroutine, $class
becomes Cow
(the first argument). So when we get to the step of invoking $class->sound
, it'll be looking for Cow->sound
, which gets it on the first try without looking at @ISA
. Success!
This magical @ISA
variable has declared that Cow
"is a" Animal
. Note that it's an array, not a simple single value, because on rare occasions, it makes sense to have more than one parent class searched for the missing methods.
If Animal
also had an @ISA
, then we'd check there too. The search is recursive, depth-first, left-to-right in each @ISA
by default (see mro for alternatives). Typically, each @ISA
has only one element (multiple elements means multiple inheritance and multiple headaches), so we get a nice tree of inheritance.
When we turn on use strict
, we'll get complaints on @ISA
, since it's not a variable containing an explicit package name, nor is it a lexical ("my") variable. We can't make it a lexical variable though (it has to belong to the package to be found by the inheritance mechanism), so there's a couple of straightforward ways to handle that.
The easiest is to just spell the package name out:
@Cow::ISA = qw(Animal);
Or declare it as package global variable:
package Cow;
our @ISA = qw(Animal);
Or allow it as an implicitly named package variable:
package Cow;
use vars qw(@ISA);
@ISA = qw(Animal);
If the Animal
class comes from another (object-oriented) module, then just employ use base
to specify that Animal
should serve as the basis for the Cow
package Cow;
use base qw(Animal);
Now that's pretty darn simple!
Let's add a mouse, which can barely be heard:
# Animal package from before
{ package Mouse;
@ISA = qw(Animal);
sub sound { "squeak" }
sub speak {
my $class = shift;
print "a $class goes ", $class->sound, "!\n";
print "[but you can barely hear it!]\n";
which results in:
a Mouse goes squeak!
[but you can barely hear it!]
Here, Mouse
has its own speaking routine, so Mouse->speak
doesn't immediately invoke Animal->speak
. This is known as "overriding". In fact, we don't even need to say that a Mouse
is an Animal
at all, because all of the methods needed for speak
are completely defined for Mouse
; this is known as "duck typing": "If it walks like a duck and quacks like a duck, I would call it a duck" (James Whitcomb). However, it would probably be beneficial to allow a closer examination to conclude that a Mouse
is indeed an Animal
, so it is actually better to define Mouse
with Animal
as its base (that is, it is better to "derive Mouse
from Animal
Moreover, this duplication of code could become a maintenance headache (though code-reuse is not actually a good reason for inheritance; good design practices dictate that a derived class should be usable wherever its base class is usable, which might not be the outcome if code-reuse is the sole criterion for inheritance. Just remember that a Mouse
should always act like an Animal
So, let's make Mouse
an Animal
The obvious solution is to invoke Animal::speak
# Animal package from before
{ package Mouse;
@ISA = qw(Animal);
sub sound { "squeak" }
sub speak {
my $class = shift;
print "[but you can barely hear it!]\n";
Note that we're using Animal::speak
. If we were to invoke Animal->speak
instead, the first parameter to Animal::speak
would automatically be "Animal"
rather than "Mouse"
, so that the call to $class->sound
in Animal::speak
would become Animal->sound
rather than Mouse->sound
Also, without the method arrow ->
, it becomes necessary to specify the first parameter to Animal::speak
ourselves, which is why $class
is explicitly passed: Animal::speak($class)
However, invoking Animal::speak
directly is a mess: Firstly, it assumes that the speak
method is a member of the Animal
class; what if Animal
actually inherits speak
from its own base? Because we are no longer using ->
to access speak
, the special method look up mechanism wouldn't be used, so speak
wouldn't even be found!
The second problem is more subtle: Animal
is now hardwired into the subroutine selection. Let's assume that Animal::speak
does exist. What happens when, at a later time, someone expands the class hierarchy by having Mouse
inherit from Mus
instead of Animal
. Unless the invocation of Animal::speak
is also changed to an invocation of Mus::speak
, centuries worth of taxonomical classification could be obliterated!
What we have here is a fragile or leaky abstraction; it is the beginning of a maintenance nightmare. What we need is the ability to search for the right method wih as few assumptions as possible.
A better solution is to tell Perl where in the inheritance chain to begin searching for speak
. This can be achieved with a modified version of the method arrow ->
So, the improved Mouse
class is:
# same Animal as before
{ package Mouse;
# same @ISA, &sound as before
sub speak {
my $class = shift;
print "[but you can barely hear it!]\n";
Using this syntax, we start with Animal
to find speak
, and then use all of Animal
's inheritance chain if it is not found immediately. As usual, the first parameter to speak
would be $class
, so we no longer need to pass $class
explicitly to speak
But what about the second problem? We're still hardwiring Animal
into the method lookup.
If Animal
is replaced with the special placeholder SUPER
in that invocation, then the contents of Mouse
's @ISA
are used for the search, beginning with $ISA[0]
. So, all of the problems can be fixed as follows:
# same Animal as before
{ package Mouse;
# same @ISA, &sound as before
sub speak {
my $class = shift;
print "[but you can barely hear it!]\n";
In general, SUPER::speak
means look in the current package's @ISA
for a class that implements speak
, and invoke the first one found. The placeholder is called SUPER
, because many other languages refer to base classes as "superclasses", and Perl likes to be eclectic.
Note that a call such as
does not look in the @ISA
of $class
unless $class
happens to be the current package.
So far, we've seen the method arrow syntax:
or the equivalent:
$a = "Class";
which constructs an argument list of:
("Class", @args)
and attempts to invoke:
Class::method("Class", @args);
However, if Class::method
is not found, then @Class::ISA
is examined (recursively) to locate a class (a package) that does indeed contain method
, and that subroutine is invoked instead.
Using this simple syntax, we have class methods, (multiple) inheritance, overriding, and extending. Using just what we've seen so far, we've been able to factor out common code (though that's never a good reason for inheritance!), and provide a nice way to reuse implementations with variations.
Now, what about data?
Let's start with the code for the Animal
class and the Horse
{ package Animal;
sub speak {
my $class = shift;
print "a $class goes ", $class->sound, "!\n";
{ package Horse;
@ISA = qw(Animal);
sub sound { "neigh" }
This lets us invoke Horse->speak
to ripple upward to Animal::speak
, calling back to Horse::sound
to get the specific sound, and the output of:
a Horse goes neigh!
But all of our Horse objects would have to be absolutely identical. If we add a subroutine, all horses automatically share it. That's great for making horses the same, but how do we capture the distinctions of an individual horse? For example, suppose we want to give our first horse a name. There's got to be a way to keep its name separate from the other horses.
That is to say, we want particular instances of Horse
to have different names.
In Perl, any reference can be an "instance", so let's start with the simplest reference that can hold a horse's name: a scalar reference.
my $name = "Mr. Ed";
my $horse = \$name;
So, now $horse
is a reference to what will be the instance-specific data (the name). The final step is to turn this reference into a real instance of a Horse
by using the special operator bless
bless $horse, Horse;
This operator stores information about the package named Horse
into the thing pointed at by the reference. At this point, we say $horse
is an instance of Horse
. That is, it's a specific horse. The reference is otherwise unchanged, and can still be used with traditional dereferencing operators.
The method arrow can be used on instances, as well as classes (the names of packages). So, let's get the sound that $horse
my $noise = $horse->sound("some", "unnecessary", "args");
To invoke sound
, Perl first notes that $horse
is a blessed reference (and thus an instance). It then constructs an argument list, as per usual.
Now for the fun part: Perl takes the class in which the instance was blessed, in this case Horse
, and uses that class to locate the subroutine. In this case, Horse::sound
is found directly (without using inheritance). In the end, it is as though our initial line were written as follows:
my $noise = Horse::sound($horse, "some", "unnecessary", "args");
Note that the first parameter here is still the instance, not the name of the class as before. We'll get neigh
as the return value, and that'll end up as the $noise
variable above.
If Horse::sound had not been found, we'd be wandering up the @Horse::ISA
array, trying to find the method in one of the superclasses. The only difference between a class method and an instance method is whether the first parameter is an instance (a blessed reference) or a class name (a string).
Because we get the instance as the first parameter, we can now access the instance-specific data. In this case, let's add a way to get at the name:
{ package Horse;
@ISA = qw(Animal);
sub sound { "neigh" }
sub name {
my $self = shift;
Inside Horse::name
, the @_
array contains:
($horse, "some", "unnecessary", "args")
so the shift
stores $horse
into $self
. Then, $self
gets de-referenced with $$self
as normal, yielding "Mr. Ed"
It's traditional to shift
the first parameter into a variable named $self
for instance methods and into a variable named $class
for class methods.
Then, the following line:
print $horse->name, " says ", $horse->sound, "\n";
Mr. Ed says neigh.
Of course, if we constructed all of our horses by hand, we'd most likely make mistakes from time to time. We're also violating one of the properties of object-oriented programming, in that the "inside guts" of a Horse are visible. That's good if you're a veterinarian, but not if you just like to own horses. So, let's have the Horse class handle the details inside a class method:
{ package Horse;
@ISA = qw(Animal);
sub sound { "neigh" }
sub name {
my $self = shift; # instance method, so use $self
sub named {
my $class = shift; # class method, so use $class
my $name = shift;
bless \$name, $class;
Now with the new named
method, we can build a horse as follows:
my $horse = Horse->named("Mr. Ed");
Notice we're back to a class method, so the two arguments to Horse::named
are Horse
and Mr. Ed
. The bless
operator not only blesses \$name
, it also returns that reference.
This Horse::named
method is called a "constructor".
We've called the constructor named
here, so that it quickly denotes the constructor's argument as the name for this particular Horse
. You can use different constructors with different names for different ways of "giving birth" to the object (like maybe recording its pedigree or date of birth). However, you'll find that most people coming to Perl from more limited languages use a single constructor named new
, with various ways of interpreting the arguments to new
. Either style is fine, as long as you document your particular way of giving birth to an object. (And you were going to do that, right?)
But was there anything specific to Horse
in that method? No. Therefore, it's also the same recipe for building anything else that inherited from Animal
, so let's put name
and named
{ package Animal;
sub speak {
my $class = shift;
print "a $class goes ", $class->sound, "!\n";
sub name {
my $self = shift;
sub named {
my $class = shift;
my $name = shift;
bless \$name, $class;
{ package Horse;
@ISA = qw(Animal);
sub sound { "neigh" }
Ahh, but what happens if we invoke speak
on an instance?
my $horse = Horse->named("Mr. Ed");
We get a debugging value:
a Horse=SCALAR(0xaca42ac) goes neigh!
Why? Because the Animal::speak
routine is expecting a classname as its first parameter, not an instance. When the instance is passed in, we'll end up using a blessed scalar reference as a string, and that shows up as we saw it just now.
All we need is for a method to detect if it is being called on a class or called on an instance. The most straightforward way is with the ref
operator. This returns a string (the classname) when used on a blessed reference, and an empty string when used on a string (like a classname). Let's modify the name
method first to notice the change:
sub name {
my $either = shift;
ref $either ? $$either : "Any $either";
Here, the ?:
operator comes in handy to select either the dereference or a derived string. Now we can use this with either an instance or a class. Note that I've changed the first parameter holder to $either
to show that this is intended:
my $horse = Horse->named("Mr. Ed");
print Horse->name, "\n"; # prints "Any Horse\n"
print $horse->name, "\n"; # prints "Mr Ed.\n"
and now we'll fix speak
to use this:
sub speak {
my $either = shift;
print $either->name, " goes ", $either->sound, "\n";
And since sound
already worked with either a class or an instance, we're done!
Let's train our animals to eat:
{ package Animal;
sub named {
my $class = shift;
my $name = shift;
bless \$name, $class;
sub name {
my $either = shift;
ref $either ? $$either : "Any $either";
sub speak {
my $either = shift;
print $either->name, " goes ", $either->sound, "\n";
sub eat {
my $either = shift;
my $food = shift;
print $either->name, " eats $food.\n";
{ package Horse;
@ISA = qw(Animal);
sub sound { "neigh" }
{ package Sheep;
@ISA = qw(Animal);
sub sound { "baaaah" }
And now try it out:
my $horse = Horse->named("Mr. Ed");
which prints:
Mr. Ed eats hay.
Any Sheep eats grass.
An instance method with parameters gets invoked with the instance, and then the list of parameters. So that first invocation is like:
Animal::eat($horse, "hay");
What if an instance needs more data? Most interesting instances are made of many items, each of which can in turn be a reference or even another object. The easiest way to store these is often in a hash. The keys of the hash serve as the names of parts of the object (often called "instance variables" or "member variables"), and the corresponding values are, well, the values.
But how do we turn the horse into a hash? Recall that an object was any blessed reference. We can just as easily make it a blessed hash reference as a blessed scalar reference, as long as everything that looks at the reference is changed accordingly.
Let's make a sheep that has a name and a color:
my $bad = bless { Name => "Evil", Color => "black" }, Sheep;
so $bad->{Name}
has Evil
, and $bad->{Color}
has black
. But we want to make $bad->name
access the name, and that's now messed up because it's expecting a scalar reference. Not to worry, because that's pretty easy to fix up.
One solution is to override Animal::name
and Animal::named
by defining them anew in Sheep
, but then any methods added later to Animal
might still mess up, and we'd have to override all of those too. Therefore, it's never a good idea to define the data layout in a way that's different from the data layout of the base classes. In fact, it's a good idea to use blessed hash references in all cases. Also, this is why it's important to have constructors do the low-level work. So, let's redefine Animal
## in Animal
sub name {
my $either = shift;
ref $either ? $either->{Name} : "Any $either";
sub named {
my $class = shift;
my $name = shift;
my $self = { Name => $name };
bless $self, $class;
Of course, we still need to override named
in order to handle constructing a Sheep
with a certain color:
## in Sheep
sub named {
my ($class, $name) = @_;
my $self = $class->SUPER::named(@_);
$$self{Color} = $class->default_color;
(Note that @_
contains the parameters to named
What's this default_color
? Well, if named
has only the name, we still need to set a color, so we'll have a class-specific default color. For a sheep, we might define it as white:
## in Sheep
sub default_color { "white" }
my $sheep = Sheep->named("Bad");
print $sheep->{Color}, "\n";
Now, there's nothing particularly specific to Sheep
when it comes to color, so let's remove Sheep::named
and implement Animal::named
to handle color instead:
## in Animal
sub named {
my ($class, $name) = @_;
my $self = { Name => $name, Color => $class->default_color };
bless $self, $class;
And then to keep from having to define default_color
for each additional class, we'll define a method that serves as the "default default" directly in Animal
## in Animal
sub default_color { "brown" }
Of course, because name
and named
were the only methods that referenced the "structure" of the object, the rest of the methods can remain the same, so speak
still works as before.
But having all our horses be brown would be boring. So let's add a method or two to get and set the color.
## in Animal
sub color {
sub set_color {
$_[0]->{Color} = $_[1];
Note the alternate way of accessing the arguments: $_[0]
is used in-place, rather than with a shift
. (This saves us a bit of time for something that may be invoked frequently.) And now we can fix that color for Mr. Ed:
my $horse = Horse->named("Mr. Ed");
print $horse->name, " is colored ", $horse->color, "\n";
which results in:
Mr. Ed is colored black-and-white
So, now we have class methods, constructors, instance methods, instance data, and even accessors. But that's still just the beginning of what Perl has to offer. We haven't even begun to talk about accessors that double as getters and setters, destructors, indirect object notation, overloading, "isa" and "can" tests, the UNIVERSAL
class, and so on. That's for the rest of the Perl documentation to cover. Hopefully, this gets you started, though.
For more information, see perlobj (for all the gritty details about Perl objects, now that you've seen the basics), perltoot (the tutorial for those who already know objects), perltooc (dealing with class data), perlbot (for some more tricks), and books such as Damian Conway's excellent Object Oriented Perl.
Some modules which might prove interesting are Class::Accessor, Class::Class, Class::Contract, Class::Data::Inheritable, Class::MethodMaker and Tie::SecureHash
Copyright (c) 1999, 2000 by Randal L. Schwartz and Stonehenge Consulting Services, Inc.
Copyright (c) 2009 by Michael F. Witten.
Permission is hereby granted to distribute this document intact with the Perl distribution, and in accordance with the licenses of the Perl distribution; derived documents must include this copyright notice intact.
Portions of this text have been derived from Perl Training materials originally appearing in the Packages, References, Objects, and Modules course taught by instructors for Stonehenge Consulting Services, Inc. and used with permission.
Portions of this text have been derived from materials originally appearing in Linux Magazine and used with permission.


text:
IBM Functions (PDO_IBM)
PDO_IBM is a driver that implements the PHP Data Objects (PDO) interface to enable access from PHP to IBM databases.
To build the PDO_IBM extension, the DB2 Client v9.1 or later must be installed on the same system as PHP. The DB2 Client can be downloaded from the IBM » Application Development Site.
Note: Note
The DB2 Client v9.1 or later supports direct access to DB2 for Linux, UNIX, and Windows v8 and v9.1 servers.
The DB2 Client v9.1 also supports access to DB2 UDB for i5 and DB2 UDB for z/OS servers using the separately purchased » DB2 Connect product.
PDO_IBM is a » PECL extension, so follow the instructions in Installation of PECL extensions to install the PDO_IBM extension. Issue the configure command to point to the location of your DB2 Client header files and libraries as follows:
bash$ ./configure --with-pdo-ibm=/path/to/sqllib[,shared]
Table of Contents
- PDO_IBM DSN — Connecting to IBM databases