Most people who have watched the evolution of technology over 
recent decades remember a time when storage was expensive and 
it had to be hoarded like gold. Over the last few years, however, 
the accelerating trend of Moore’s Law has made data storage al-
most “too cheap to meter” (as they used to predict about nuclear 
power). Although this opens many opportunities, it also means 
that people keep data around for a long time, since it doesn’t make 
sense to delete anything, and they may keep data around in many 
different formats. As a result, the world is full of different data for-
mats, some of which are proprietary - designed and owned by a 
single company such as SAS - and some of which are open, such as 
the lowly but infinitely useful “comma separated variable,” or CSV 
In fact, one of the basic dividing lines in data formats is whether 
data are human readable or not. Formats that are not human read-
able, often called binary formats, are very efficient in terms of how 
much data they can pack in per kilobyte, but are also squirrelly in 
the sense that it is hard to see what is going on inside of the format. 
As you might expect, human readable formats are inefficient from 
a storage standpoint, but easy to diagnose when something goes 
wrong. For high volume applications, such as credit card process-
ing, the data that is exchanged between systems is almost univer-
sally in binary formats. When a data set is archived for later reuse, 
for example in the case of government data sets available to the 
public, they are usually available in multiple formats, at least one 
of which is a human readable format.
Another dividing line, as mentioned above is between proprietary 
and open formats. One of the most common ways of storing and 
sharing small datasets is as Microsoft Excel spreadsheets. Although 
this is a proprietary format, owned by Microsoft, it has also be-
come a kind of informal and ubiquitous standard. Dozens of differ-
ent software applications can read Excel formats (there are several 
different formats that match different versions of Excel). In con-
trast, the OpenDocument format is an open format, managed by a 
standards consortium, that anyone can use without worrying what 
the owner might do. OpenDocument format is based on XML, 
which stands for Extensible markup language. XML is a whole 
topic in and of itself, but briefly it is a data exchange format de-
signed specifically to work on the Internet and is both human and 
machine readable. XML is managed by the W3C consortium, 
which is responsible for developing and maintaining the many 
standards and protocols that support the web.
As an open source program with many contributors, R offers a 
wide variety of methods of connecting with external data sources. 
This is both a blessing and a curse. There is a solution to almost 
any data access problem you can imagine with R, but there is also 
a dizzying array of options available such that it is not always obvi-
ous what to choose. We’ll tackle this problem in two different 
ways. In the first half of this chapter we will look at methods for 
importing existing datasets. These may exist on a local computer 
or on the Internet but the characteristic they share in common is 
that they are contained (usually) within one single file. The main 
trick here is to choose the right command to import that data into 
R. In the second half of the chapter, we will consider a different 
strategy, namely linking to a “source” of data that is not a file. 
Many data sources, particularly databases, exist not as a single dis-
crete file, but rather as a system. The system provides methods or 
calls to “query” data from the system, but from the perspective of 
the user (and of R) the data never really take the form of a file.
Pdf rotate all pages - rotate PDF page permanently in, ASP.NET, MVC, Ajax, WinForms, WPF
Empower Users to Change the Rotation Angle of PDF File Page Using C#
rotate individual pdf pages reader; pdf reverse page order online
Pdf rotate all pages - VB.NET PDF Page Rotate Library: rotate PDF page permanently in, ASP.NET, MVC, Ajax, WinForms, WPF
PDF Document Page Rotation in Visual Basic .NET Class Application
pdf reverse page order; pdf rotate all pages
The first and easiest strategy for getting data into R is to use the 
data import dialog in R-Studio. In the upper right hand pane of R-
Studio, the “Workspace” tab gives views of currently available 
data objects, but also has a set of buttons at the top for managing 
the work space. One of the choices there is the “Import Dataset” 
button: This enables a drop down menu where one choice is to im-
port, “From Text File...” If you click this option and choose an ap-
propriate file you will get a screen like this:
The most important stuff is on the left side. Heading controls 
whether or not the first line of the text file is treated as containing 
variable names. The separator drop down gives a choice of differ-
ent characters that separate the fields/columns in the data. R-
Studio tries to guess the appropriate choice here based on a scan of 
the data. In this case it guessed right by choosing “tab-delimited.” 
As mentioned above, tab-delimited and comma-delimited are the 
two most common formats used for interchange between data 
programs.The next drop down is for “Decimal” and this option ac-
counts for the fact the a dot is used in the U.S. while a comma may 
be used for the decimal point in Europe and elsewhere. Finally, the 
“Quote” drop down controls which character is used to contain 
quoted string/text data. The most common method is double 
Of course, we skipped ahead a bit here because we assumed that 
an appropriate file of data was available. It might be useful to see 
some examples of human readable data:
Name, Age, Gender


The above is a very simple example of a comma delimited file 
where the first row contains a “header,” i.e. the information about 
the names of variables. The second and subsequent rows contain 
actual data. Each field is separated by a comma, and the text 
strings are enclosed in double quotes. The same file tab-delimited 
might look like this:
Age! Gender

“Fred”! 22! ”M”

“Ginger”! 21! ”F”
Of course you can’t see the tab characters on the screen, but there is 
one tab character in between each pair of values. In each case, for 
both comma- and tab-delimited, one line equals one row. The end 
VB.NET PDF Page Delete Library: remove PDF pages in, ASP.
NET example for how to delete several defined pages from a PDF document Dim detelePageindexes = New Integer() {1, 3, 5, 7, 9} ' Delete pages. All Rights Reserved
pdf rotate page; how to rotate a page in pdf and save it
VB.NET PDF Page Insert Library: insert pages into PDF file in vb.
doc2.InsertPages(pages, pageIndex) ' Output the new document how to use VB to insert an empty page to a specific location of current PDF file All Rights Reserved
save pdf rotate pages; pdf rotate page and save
of a line is marked, invisibly, with a so called “newline” character. 
On occasion you may run into differences between different operat-
ing systems on how this end of line designation is encoded. 
Files containing comma or tab delimited data are ubiquitous across 
the Internet, but sometimes we would like to gain direct access to 
binary files in other formats. There are a variety of packages that 
one might use to access binary data. A comprehensive access list 
appears here:
This page shows a range of methods for obtaining data from a 
wide variety of programs and formats. Because Excel is such a 
widely used program for small, informal data sets, we will use it as 
an example here to illustrate both the power and the pitfalls of ac-
cessing binary data with R. Down near the bottom of the page men-
tioned just above there are several paragraphs of discussion of how 
to access Excel files with R. In fact, the first sentence mentions that 
one of the most commonly asked data questions about R is how to 
access Excel data. 
Interestingly, this is one area where Mac and Linux users are at a 
disadvantage relative to Windows users. This is perhaps because 
Excel is a Microsoft product, originally written to be native to Win-
dows, and as a result it is easier to create tools that work with Win-
dows. One example noted here is the package called RODBC. The 
acronym ODBC stands for Open Database Connection, and this is  
a Windows facility for exchanging data among Windows pro-
grams. Although there is a proprietary ODBC driver available for 
the Mac, most Mac users will want to try a different method for get-
ting access to Excel data. 
Another Windows-only package for R is called xlsReadWrite. This 
package provides convenient one-command calls for importing 
data directly from Excel spreadsheets or exporting it directly to 
spreadsheets. There are also more detailed commands that allow 
manipulating individual cells.
Two additional packages, xlsx and XLConnect, supposedly will 
work with the Mac, but at the time of this writing both of these 
packages had version incompatibilities that made it impossible to 
install the packages directly into R. Note that the vast majority of 
packages provide the raw “source code” and so it is theoretically 
possible, but generally highly time consuming, to “compile” your 
own copies of these packages to create your own installation. 
Fortunately, a general purpose data manipulation package called 
gdata provides essential facilities for importing spreadsheet files. 
In the example that follows, we will use a function from gdata to 
read Excel data directly from a website. The gdata package is a 
kind of “Swiss Army Knife” package containing many different 
functions for accessing and manipulating data. For example, you 
may recall that R uses the value “NA” to represent missing data. 
Frequently, however, it is the case that data sets contain other val-
ues, such as 999, to represent missing data. The gdata package has 
several functions that find and transform these values to be consis-
tent with R’s strategy for handling missing data.
Begin by using install.package() and library() functions to prepare 
the gdata package for use:
> install.packages("gdata")
# ... lots of output here
C# PDF Page Delete Library: remove PDF pages in, ASP.NET
1. public void DeletePages(int[] pageIndexes). Description: Delete specified pages from the input PDF file. Parameters: All Rights Reserved.
rotate pdf page; how to rotate all pages in pdf
C# PDF Page Insert Library: insert pages into PDF file in
how to merge PDF document files by C# code, how to rotate PDF document page to insert empty pages to a specific location of current PDF file. All Rights Reserved
pdf rotate single page and save; how to rotate one pdf page
> library("gdata")
gdata: read.xls support for 'XLS' (Excel 97-2004) 
gdata: ENABLED.
gdata: read.xls support for 'XLSX' (Excel 2007+) 
files ENABLED.
Of course, you could also use the EnsurePackage() function that 
we developed in an earlier chapter, but it was important here to 
see the output from the library() function. Note that the gdata pack-
age reported some diagnostics about the different versions of Excel 
data that it supports. Note that this is one of the major drawbacks 
of binary data formats, particularly proprietary ones: you have to 
make sure that you have the right software to access the different 
versions of data that you might encounter. In this case it looks like 
we are covered for the early versions of Excel (97-2004) as well as 
later versions of Excel (2007+). We must always be on the lookout, 
however, for data that is stored in even newer versions of Excel 
that may not be supported by gdata or other packages.
Now that gdata is installed, we can use the read.xls() function that 
it provides. The documentation for the gdata package and the 
read.xls() function is located here:
A review of the documentation reveals that the only required argu-
ment to this function is the location of the XLS file, and that this lo-
cation can be a pathname, a web location with http, or an Internet 
location with ftp (file transfer protocol, a way of sending and re-
ceiving files without using a web browser). If you hearken back to 
a very early chapter in this book, you may remember that we ac-
cessed some census data that had population counts for all the dif-
ferent U.S. states. For this example, we are going to read the Excel 
file containing that data directly into a dataframe using the 
read.xls() function:
> testFrame<-read.xls( +

trying URL 
Content type 'application/' length 31232 
bytes (30 Kb)
opened URL
downloaded 30 Kb
The command in the first three lines above provides the URL of the 
Excel file to the read.xls() function. The subsequent lines of output 
show the function attempting to open the URL, succeeding, and 
downloading 30 kilobytes of data.
Next, let’s take a look at what we got back. In R-Studio we can 
click on the name of the dataframe in the upper right hand data 
pane or we can use this command:
> View(testFrame)
VB.NET PDF - WPF PDF Viewer for VB.NET Program
Users can rotate PDF pages, zoom in or zoom out PDF pages and WPF PDF Viewer for VB.NET is a PDF utility annotation rectangle, polygon and so on are all can be
rotate pages in pdf expert; pdf save rotated pages
C# WPF PDF Viewer SDK to view PDF document in C#.NET
Compatible with all Windows systems and supports .NET Framework 2.0 & above versions. A powerful .NET WPF component able to rotate one PDF page or whole PDF
rotate pages in pdf online; saving rotated pdf pages
Either method will show the contents of the dataframe in the up-
per left hand window of R-Studio. Alternatively, we could use the 
str() function to create a summary of the structure of testFrame:
> str(testFrame)
65 obs. of  10 variables: Factor w/ 65 levels "",".Alabama",..: 
62 53 1 64 55 54 60 65 2 3 ...
$ X                                                                                                           
: Factor w/ 60 levels "","1,052,567",..: 1 59 60 
27 38 47 10 49 32 50 ...
$ X.1                                                                                                         
: Factor w/ 59 levels "","1,052,567",..: 1 1 59 
27 38 47 10 49 32 50 ...
$ X.2                                                                                                         
: Factor w/ 60 levels "","1,052,528",..: 1 60 21 
28 39 48 10 51 33 50 ...
$ X.3                                                                                                         
: Factor w/ 59 levels "","1,051,302",..: 1 1 21 
28 38 48 10 50 33 51 ...
$ X.4                                                                                                         
: logi  NA NA NA NA NA NA ...
$ X.5                                                                                                         
: logi  NA NA NA NA NA NA ...
$ X.6                                                                                                         
: logi  NA NA NA NA NA NA ...
$ X.7                                                                                                         
: logi  NA NA NA NA NA NA ...
$ X.8                                                                                                         
: logi  NA NA NA NA NA NA ...
The last few lines are reminiscent of that late 60s song entitled, 
“"Na Na Hey Hey Kiss Him Goodbye." Setting aside all the NA 
NA NA NAs, however, the overall structure is 65 observations of 
10 variables, signifying that the spreadsheet contained 65 rows and 
10 columns of data. The variable names that follow are pretty bi-
zarre. The first variable name is:
What a mess! It is clear that read.xls() treated the upper leftmost 
cell as a variable label, but was flummoxed by the fact that this was  
really just a note to human users of the spreadsheet (the variable 
labels, such as they are, came on lower rows of the spreadsheet). 
Subsequent variable names include X, X.1, and X.2: clearly the 
read.xls() function did not have an easy time getting the variable 
names out of this file.
The other worrisome finding from str() is that all of our data are 
“factors.” This indicates that R did not see the incoming data as 
numbers, but rather as character strings that it interpreted as factor 
data. Again, this is a side effect of the fact that some of the first 
cells that read.xls() encountered were text rather than numeric. The 
numbers came much later in the sheet. This also underscores the 
VB.NET PDF - View PDF with WPF PDF Viewer for VB.NET
Compatible with all Windows systems and supports .NET Framework 2.0 & above versions. Able to rotate one PDF page or whole PDF while in viewing.
rotate pdf pages by degrees; pdf expert rotate page
C# TIFF: How to Rotate TIFF Using C# Code in .NET Imaging
VB.NET How-to, VB.NET PDF, VB.NET Word, VB.NET Excel, VB TIFFPage)doc.GetPage(0); page.Rotate(RotateOder.Clockwise90); doc.Save(@"C:\rotate.tif All Rights Reserved
save pdf after rotating pages; change orientation of pdf page
idea that it is much better to export a data set in a more regular, 
structured format such as CSV rather than in the original spread-
sheet format. Clearly we have some work to do if we are to make 
use of these data as numeric population values.  
First, we will use an easy trick to get rid of stuff we don’t need. The 
Census bureau put in three header rows that we can eliminate like 
> testFrame<-testFrame[-1:-3,]
The minus sign used inside the square brackets refers to the index 
of rows that should be eliminated from the dataframe. So the nota-
tion -1:-3 gets rid of the first three rows. We also leave the column 
designator empty so that we can keep all columns for now. So the 
interpretation of all of the notation within the square brackets is 
that rows 1 through 3 should be dropped, all other rows should be 
included, and all columns should be included. We assign the result 
back to the same data object thereby replacing the original with 
our new, smaller, cleaner version. 
Next, we know that of the ten variables we got from read.xls(), 
only the first five are useful to us (the last five seem to be blank). So 
this command keeps the first five columns of the dataframe:
> testFrame<-testFrame[,1:5]
In the same vein, the tail() function shows us that the last few rows 
just contained some census bureau notes:
> tail(testFrame,5)
So we can safely eliminate those like this:
> testFrame<-testFrame[-58:-62,]
If you’re alert you will notice that we could have combined some 
of these commands, but for the sake of clarity we have done each 
operation individually. The result (which you can check in the up-
per right hand pane of R-Studio) is a dataframe with 57 rows and 
five observations. Now we are ready to perform a couple of data 
transformations. Before we start these, let’s give our first column a 
more reasonable name:
> testFrame$region <- testFrame[,1]
We’ve used a little hack here to avoid typing out the ridiculously 
long name of that first variable/column. We’ve used the column 
notation in the square brackets on the right hand side of the expres-
sion to refer to the first column (the one with the ridiculous name) 
and simply copied the data into a new column entitled “region.” 
Let’s also remove the offending column with the stupid name so 
that it does not cause us problems later on:
> testFrame<-testFrame[,-1]
Next, we can change formats and data types as needed. We can re-
move the dots from in front of the state names very easily with 
> testFrame$region <- str_replace( +

Don’t forget that str_replace() is part of the stringr package, and 
you will have to use install.packages() and library() to load it if it is 
not already in place. The two backslashes in the string expression 
above are called “escape characters” and they force the dot that fol-
lows to be treated as a literal dot rather than as a wildcard charac-
ter. The dot on its own is a wildcard that matches one instance of 
any character.
Next, we can use str_replace_all() and as.numeric() to convert the 
data contained in the population columns to usable numbers. Re-
member that those columns are now represented as R “factors” 
and what we are doing is taking apart the factor labels (which are 
basically character strings that look like this: “308,745,538”) and 
making them into numbers. This is sufficiently repetitive that we 
could probably benefit by created our own function call to do it:
# Numberize() - Gets rid of commas and other junk and 
# converts to numbers
# Assumes that the inputVector is a list of data that 
# can be treated as character strings
Numberize <- function(inputVector)
# Get rid of commas
# Get rid of spaces
inputVector<-str_replace_all(inputVector," ","")
This function is flexible in that it will deal with both unwanted 
commas and spaces, and will convert strings into numbers 
whether they are integers or not (i.e., possibly with digits after the 
decimal point). So we can now run this a few times to create new 
vectors on the dataframe that contain the numeric values we 
testFrame$april10census <-Numberize(testFrame$X)
testFrame$april10base <-Numberize(testFrame$X.1)
testFrame$july10pop <-Numberize(testFrame$X.2)
testFrame$july11pop <-Numberize(testFrame$X.3)
By the way, the choice of variable names for the new columns in 
the dataframe was based on an examination of the original data set 
that was imported by read.xls(). You can (and should) confirm that 
the new columns on the dataframe are numeric. You can use str() 
to accomplish this. 
We’ve spent half a chapter so far just looking at one method of im-
porting data from an external file (either on the web or local stor-
age). A lot of our time was spent conditioning the data we got in 
order to make it usable for later analysis. Herein lies a very impor-
tant lesson (or perhaps two). An important, and sometimes time 
consuming aspect of what data scientists do is to make sure that 
data are “fit for the purpose” to which they are going to be put. We 
had the convenience of importing a nice data set directly from the 
web with one simple command, and yet getting those data actually 
ready to analyze took several additional steps.
A related lesson is that it is important and valuable to try to auto-
mate as many of these steps as possible. So when we saw that num-
bers had gotten stored as factor labels, we moved immediately to 
create a general function that would convert these to numbers. Not 
only does this save a lot of future typing, it prevents mistakes from 
creeping into our processes.
Now we are ready to consider the other strategy for getting access 
to data: querying it from external databases. Depending upon your 
familiarity with computer programming and databases, you may 
notice that the abstraction is quite a bit different here. Earlier in the 
chapter we had a file (a rather messy one) that contained a com-
plete copy of the data that we wanted, and we read that file into R 
and stored it in our local computer’s memory (and possibly later 
on the hard disk for safekeeping). This is a good and reasonable 
strategy for small to medium sized datasets, let’s say just for the 
sake of argument anything up to 100 megabytes.
But what if the data you want to work with is really large - too 
large to represent in your computer’s memory all at once and too 
large to store on your own hard drive. This situation could occur 
even with smaller datasets if the data owner did not want people 
making complete copies of their data, but rather wanted everyone 
who was using it to work from one “official” version of the data. 
Similarly, if data do need to be shared among multiple users, it is 
much better to have them in a database that was designed for this 
purpose: For the most part R is a poor choice for maintaining data 
that must be used simultaneously by more than one user. For these 
reasons, it becomes necessary to do one or both of the following 
1. Allow R to send messages to the large, remote database asking 
for summaries, subsets, or samples of the data.
2. Allow R to send computation requests to a distributed data proc-
essing system asking for the results of calculations performed on 
the large remote database.
Like most contemporary programming languages, R provides sev-
eral methods for performing these two tasks. The strategy is the 
same across most of these methods: a package for R provides a “cli-
ent” that can connect up to the database server. The R client sup-
ports sending commands - mostly in SQL, structured query lan-
guage - to the database server. The database server returns a result 
to the R client, which places it in an R data object (typically a data 
frame) for use in further processing or visualization.
The R community has developed a range of client software to en-
able R to connect up with other databases. Here are the major data-
bases for which R has client software:
RMySQL - Connects to MySQL, perhaps the most popular open 
source database in the world. MySQL is the M in “LAMP” which 
is the acronym for Linux, Apache, MySQL, and PHP. Together, 
these four elements provide a complete solution for data driven 
web applications.
ROracle - Connects with the widely used Oracle commercial da-
tabase package. Oracle is probably the most widely used com-
mercial database package. Ironically, Oracle acquired Sun Micro-
systems a few years ago and Sun developers predominate in de-
velopment and control of the open source MySQL syste,
RPostgreSQL - Connects with the well-developed, full featured 
PostgreSQL (sometimes just called Postgres) database system. 
PostgreSQL is a much more venerable system than MySQL and 
has a much larger developer community. Unlike MySQL, which 
is effectively now controlled by Oracle, PostgreSQL has a devel-
oper community that is independent of any company and a li-
censing scheme that allows anybody to modify and reuse the 
RSQlite - Connects with SQlite, another open source, independ-
ently developed database system. As the name suggests, SQlite 
has a very light “code footprint” meaning that it is fast and com-
RMongo - Connects with the MongoDB system, which is the 
only system here that does not use SQL. Instead, MongoDB uses 
JavaScript to access data. As such it is well suited for web devel-
opment applications.
RODBC - Connects with ODBC compliant databases, which in-
clude Microsoft’s SQLserver, Microsoft Access, and Microsoft Ex-
cel, among others. Note that these applications are native to Win-
dows and Windows server, and as such the support for Linux 
and Mac OS is limited.
For demonstration purposes, we will use RMySQL. This requires 
installing a copy of MySQL on your computer. Use your web 
browser to go to this page:
Then look for the “MySQL Community Server.” The term commu-
nity in this context refers to the free, open source developer com-
munity version of MySQL. Note that there are also commercial ver-
sions of SQL developed and marketed by various companies in-
cluding Oracle. Download the version of MySQL Community 
Server that is most appropriate for your computer’s operating sys-
tem and install it. Note that unlike user applications, such as a 
word processor, there is no real user interface to server software 
like the MySQL Community Server. Instead, this software runs in 
the “background” providing services that other programs can use. 
This is the essence of the client-server idea. In many cases the 
server is on some remote computer to which we do not have physi-
cal access. In this case, we will run the server on our local com-
puter so that we can complete the demonstration. 
On the Mac installation used in preparation of this chapter, after 
installing the MySQL server software, it was also important to in-
stall the “MySQL Preference Pane,” in order to provide a simple 
graphical interface for turning the server on and off. Because we 
are just doing a demonstration here, and we want to avoid future 
security problems, it is probably sensible to turn MySQL server off 
when we are done with the demonstration. In Windows, you can 
use MySQL Workbench to control the server settings on your local 
Returning to R, use install.packages() and library() to prepare the 
RMySQL package for use. If everything is working the way it 
should, you should be able to run the following command from 
the command line:
> con <- dbConnect(dbDriver("MySQL"), dbname = "test")
The dbConnect() function establishes a linkage or “connection” be-
tween R and the database we want to use. This underscores the 
point that we are connecting to an “external” resource and we 
must therefore manage the connection. If there were security con-
trols involved, this is where we would provide the necessary infor-
mation to establish that we were authorized users of the database. 
In this case, because we are on a “local server” of MySQL, we don’t 
need to provide these. The dbDriver() function provided as an ar-
gument to dbConnect specifies that we want to use a MySQL cli-
ent. The database name - specified as dbname=”test” - is just a 
placeholder at this point. We can use the dbListTables() function to 
see what tables are accessible to us (for our purposes, a table is just 
like a dataframe, but it is stored inside the database system):
> dbListTables(con)
The response “character(0)” means that there is an empty list, so 
no tables are available to us. This is not surprising, because we just 
installed MySQL and have not used it for anything yet. Unless you 
have another database available to import into MySQL, we can just 
use the census data we obtained earlier in the chapter to create a 
table in MySQL:
> dbWriteTable(con, "census", testFrame, +

overwrite = TRUE)
[1] TRUE
Take note of the arguments supplied to the dbWriteTable() func-
tion. The first argument provides the database connection that we 
established with the dbConnect() function. The “census” argument 
gives our new table in MySQL a name. We use testFrame as the 
source of data - as noted above a dataframe and a relational data-
base table are very similar in structure. Finally, we provide the ar-
gument overwrite=TRUE, which was not really needed in this case 
- because we know that there were no existing tables - but could be 
important in other operations where we need to make sure to re-
place any old table that may have been left around from previous 
work. The function returns the logical value TRUE to signal that it 
was able to finish the request that we made. This is important in 
programming new functions because we can use the signal of suc-
cess or failure to guide subsequent steps and provide error or suc-
cess messages.
Now if we run dbListTables() we should see our new table:
> dbListTables(con)
[1] "census"
Now we can run an SQL query on our table:
> dbGetQuery(con, "SELECT region, july11pop FROM   

census WHERE july11pop<1000000")
region july11pop
1               Alaska    722718
2             Delaware    907135
3 District of Columbia    617996
4              Montana    998199
5         North Dakota    683932
6         South Dakota    824082
7              Vermont    626431
8              Wyoming    568158
Note that the dbGetQuery() call shown above breaks onto two 
lines, but the string starting with SELECT has to be typed all on 
Documents you may be interested
Documents you may be interested