The following scripts can help you to login to WordPress automatically, save the WordPress session cookie, and use the cookie with subsequent curl commands to automate WordPress administration.

All of this is done using the curl command with no other dependencies (such as php). Many scripts use the php curl extension but this method is simpler and will work anywhere curl is installed without having bother with php. Few dependencies == good in my books.

The first bit is all about logging in.

# Let the fun begin

user=admin
password=pass
host=localhost
port=88

cookiejar="/tmp/wp-cookie.txt"
baseurl="http://$host:$port"
loginurl="$baseurl/wp-login.php"

#csv import / bulk delete plugins mentioned in a later section
csvtool="$baseurl/wp-admin/tools.php?page=csv-importer/csv_importer.php"
deltool="$baseurl/wp-admin/options-general.php?page=bulk-delete.php"

postdata="log=$user&pwd=$password&wp-submit=Log%20In&redirect_to=$csvtool"

[ -e $cookiejar ] && rm $cookiejar

# this will login to wp and download the session cookie
curl    --insecure \
        --connect-timeout 60 \
        --cookie-jar $cookiejar \
        --data $postdata \
        --silent \
        $loginurl

[ -e $cookiejar ] && echo "WP cookie created: $cookiejar"

# now you have a WP session cookie!

Once you run this successfully you’ll have a valid WordPress session cookie in your /tmp dir.

NOTE: The following snippet will delete all of your posts! Use with caution. This makes sense for me because I’m working on data migration to a new WordPress staging installation. Use at your own risk! You have been warned.

You need the Bulk Delete WordPress plugin for the following to work.

# prepare post data so that all posts are deleted (be careful!)
postdata=""

cats=$()
for i in {0..99} # assumes you have no more than 100 categories
do
        cats[$i]=smbd_cats%5B%5D=$i
done

cats[((i++))]="smbd_cats_all=-1"
cats[((i++))]="smbd_cats_force_delete=true"
cats[((i++))]="smbd_cats_private=false"
cats[((i++))]="submit=Bulk&20Delete&20»"
# this plugin appears to always use the same nonce
cats[((i++))]="_wpnonce=345dabd47c"
cats[((i++))]="_wp_http_referer=/wp-admin/options-general.php?page=bulk-delete.php"
cats[((i++))]="smbd_action=bulk-delete-cats"

joined=$(printf "&%s" "${cats[@]}")
postdata=${joined:1}

# delete the existing articles
curl    --insecure \
        --data $postdata \
        --cookie $cookiejar \
        --silent \
        $deltool

# now there's a clean database ready for new data

The follow snippet uses the csv importer. I’ve already generated a large quantity of csv import files and I will use the following to import the articles automatically.

# use csv importer wp plugin to import a csv file
curl    --cookie $cookiejar \
        --insecure \
        --form 'csv_import=@/home/somedude/import.csv' \
        --form 'submit=Import' \
        --form 'csv_importer_cat=' \
        --silent \
        $csvtool
# a new article has just been loaded into WP

By inspecting the forms that WordPress uses for administration one could use this method to automate any WordPress task.

I like being lazy so this really works for me.

Cheers!

GROUP BY and HAVING work together with aggregate functions such as SUM(), AVG() etc…

Here’s an example from later on in this post:

select customer_name, SUM(amount)
from customers c join purchases p on c.cid = p.cid
group by customer_name
having SUM(amount) > '20.00';

The GROUP BY statement is used in together with aggregate functions to group the results by one or more columns.

The HAVING statement is used to refine aggregated results because the WHERE keyword can’t be used with aggregate functions.

Now on to the full post for GROUP BY, HAVING, and aggregate functions.

Let’s start with some simple tables.

DROP TABLE IF EXISTS purchases;
DROP TABLE IF EXISTS customers;

-- Your set of customers
CREATE TABLE customers (
    cid integer NOT NULL,
    customer_name character varying(255),
    phone_number character varying(255),
    street_address character varying(255)
);

-- the purchases that your customers have made
CREATE TABLE purchases (
    pid integer NOT NULL,
    cid integer,
    amount numeric,
    purchase_date date
);

-- create the primary key for customers
ALTER TABLE customers
    ADD CONSTRAINT cid_pkey PRIMARY KEY (cid);

-- create the primary key for purchases
ALTER TABLE purchases
    ADD CONSTRAINT pid_pkey PRIMARY KEY (pid);

-- add the relational key so that each purchase
-- is related to a customer
ALTER TABLE purchases
    ADD CONSTRAINT cid_fkey FOREIGN KEY (cid)
    REFERENCES customers(cid) ON DELETE CASCADE;

Hopefully, it’s obvious that the above tables will track the set of purchases for each customer.

Let’s insert some data.

INSERT INTO customers
(cid, customer_name, phone_number, street_address)
VALUES
(1, 'Matt', '555 1234', '22 Tech Ave.');

INSERT INTO customers
(cid, customer_name, phone_number, street_address)
VALUES
(2, 'Susan', '334 4563', '2 Baz Lane');

INSERT INTO customers
(cid, customer_name, phone_number, street_address)
VALUES
(3, 'Sally', '333 4343', '1 Cranston Road');

INSERT INTO purchases
(pid, cid, amount, purchase_date)
VALUES
(1, 1, '20.00', '2011-08-22');

INSERT INTO purchases
(pid, cid, amount, purchase_date)
VALUES
(2, 1, '10.00', '2011-08-01');

INSERT INTO purchases
(pid, cid, amount, purchase_date)
VALUES
(3, 2, '15.00', '2011-07-11');

INSERT INTO purchases
(pid, cid, amount, purchase_date)
VALUES
(4, 3, '5.00', '2011-10-19');

INSERT INTO purchases
(pid, cid, amount, purchase_date)
VALUES
(5, 2, '5.00', '2010-08-10');

INSERT INTO purchases
(pid, cid, amount, purchase_date)
VALUES
(6, 1, '15.00', '2011-02-10');

INSERT INTO purchases
(pid, cid, amount, purchase_date)
VALUES
(7, 3, '25.00', '2010-01-02');

Now we can query things like: “show me the purchases made by Matt”

select customer_name, amount
from customers c join purchases p on c.cid = p.cid
where customer_name = 'Matt';

 customer_name | amount
---------------+--------
     Matt      | 20.00
     Matt      | 10.00
     Matt      | 15.00

That’s fairly interesting, but what if we want to know the total of the purchases made by ‘Matt’. You could just add up the amounts easily enough in your head but it would be too time consuming if there were many purchases.

So, let’s have the database to do this calculation for us. We’ll use the aggregate function SUM() on the amount column and GROUP BY on the customer_name column.

select customer_name, SUM(amount)
from customers c join purchases p on c.cid = p.cid
where customer_name = 'Matt'
group by customer_name;

The result is the sum of the purchases made by Matt.

 customer_name |  sum
---------------+--------
 Matt          | 45.00

More often, we want a report on the total purchases made by all of our customers.

Commenting out the WHERE clause will get us what we we’re looking for.

select customer_name, SUM(amount)
from customers c join purchases p on c.cid = p.cid
-- where customer_name = 'Matt'
group by customer_name;

Here’s the report on all of our customers:

 customer_name |  sum
---------------+--------
 Susan         | 20.00
 Sally         | 30.00
 Matt          | 45.00

Let’s pretend that we have a promotional campaign and we want to reward customers that have made total purchases greater than $20.00?

A WHERE clause won’t work in this case. That is, you can’t say WHERE SUM(amount) > $20.00.

HAVING is designed to work with GROUP BY to refine queries which use aggregate functions.

select customer_name, SUM(amount)
from customers c join purchases p on c.cid = p.cid
group by customer_name
having SUM(amount) > '20.00';

The result no longer contains Susan’s purchases because she hasn’t in total spent more than $20.00.

 customer_name |  sum
---------------+--------
 Sally         | 30.00
 Matt          | 45.00

You may want to create your own database and execute these queries yourself. (I suggest that you do!) Then you can try things like adding other columns to the SELECT clause to see what happens. Try making a report on the average purchase made by each customer. Can you use HAVING and GROUP BY to make use of different aggregate functions in the same query?

The key things to remember are that GROUP BY works together with HAVING and aggregate functions. Using WHERE still works to filter out rows overall but does nothing to refine information regarding grouped or aggregated information.

public class test {
	public static void main(String args[]) {
		String s1 = "abc";
		String s2 = "abc";
		if (s1 == s2)
			System.out.println(1);
		else
			System.out.println(2);
		if (s1.equals(s2))
			System.out.println(3);
		else
			System.out.println(4);
	}
}

// Prints out 1 and 3

My original assumption was that s1 and s2 would hold references to two different objects.

public class test {
	public static void main(String args[]) {
		String s1 = "abc";
		String s2 = new String("abc");

		if (s1 == s2)
			System.out.println(1);
		else
			System.out.println(2);
		if (s1.equals(s2))
			System.out.println(3);
		else
			System.out.println(4);
	}
}

// Prints out 2 and 3

Thanks to Java Prepare for the questions

The documentation says that == is the object comparison operator. It compares two references to see if they refer to the same object.

The trick here is that the assignments s1 = "abc" and s2 = "abc" together create only one object. More precisely, the statement "abc" in the first assignment creates a String object and the statement "abc" in the second assignment reuses the same reference to the first "abc" String object. The original "abc" statement creates an object in a common pool which is reused as the compiler sees fit.

If there is a variable component to the String then s1 and s2 are created as separate objects.

public class test {
	public static void main(String args[]) {
		String s1 = "abc";
		String s2 = "abc" + args[0];
		if (s1 == s2)
			System.out.println(1);
		else
			System.out.println(2);
		if (s1.equals(s2))
			System.out.println(3);
		else
			System.out.println(4);
	}
}
// run as java test
// prints out 2 and 3

Running this program with no arguments creates two separate objects that have the same contents.

Reference: String is Special

For entertainment value I have picked a fun string.

public class StringReverse {

	public static void main(String[] args) {

		String aStr = "My hovercraft is full of eels.";

		char[] charbuf = aStr.toCharArray();

		for(int i = charbuf.length - 1, j = 0; i > j; i--,j++ ) {

			if( charbuf[i] == charbuf[j]) {
				continue;
			}

			char temp = charbuf[i];
			charbuf[i] = charbuf[j];
			charbuf[j] = temp;
		}

		System.out.println(charbuf);
	}
}

I wanted to get the reference to the Hibernate Configuration object so that I could use it with SchemaExport to auto-generate the ddl and save it to a file for examination.

Here’s a simple way too do it.

<bean id="sessionFactory"
  class="org.springframework.orm.hibernate3
   .annotation.AnnotationSessionFactoryBean">
  <property name="dataSource" ref="dataSource" />
  <property name="hibernateProperties">
    <props>
      <prop key="hibernate.show_sql">true</prop>
      <prop key="hibernate.format_sql">true</prop>
      <prop key="hibernate.hbm2ddl.auto">
        create-drop</prop>
  </props>
  </property>
        <!-- details omitted... -->
</bean>

<!-- The &amp; tells Spring to fetch the Factory object,
which is distinct from the objects that it produces.
Use the encoded entity as you see it shown here
in the factory-bean attribute. i.e. &amp;
Using the factory-method attribute tells Spring which
method to call. -->
<bean id="hibernateConfiguration"
       factory-bean="&amp;sessionFactory"
       factory-method="getConfiguration" />

@Autowired
Configuration hibernateConfiguration;

@Test
public void testHibernateConfigInjection() {
  assertNotNull(hibernateConfiguration);
  assertTrue(hibernateConfiguration
    instanceof Configuration);
}

@Test
public void runSchemaGeneration() {
  SchemaExport export
    = new SchemaExport(hibernateConfiguration);
  export.setOutputFile("my-schema.sql");
  export.setDelimiter(";");
  export.execute(true, false, false, true);
}

You could load the application context explicitly in your code, but then you’d have to mention the path to the xml file. This approach hides the path from your code and so I think it is more resilient to changes in the bean xml.

I hope this saves you some time and messing around.

For your reference:
Spring Documentation – Instantiation using an instance factory method